Eu e o Diabo AzureZ: Lendo sensores BLE de C++

1
find_package(sdbus-c++ REQUIRED)

1
target_link_libraries(${PROJECT_NAME} PRIVATE SDBusCpp::sdbus-c++)

1
set(CMAKE_CXX_STANDARD 17)
2
set(CMAKE_CXX_STANDARD_REQUIRED ON)

1
#ifndef BLE_SENSOR_H
2
#define BLE_SENSOR_H
3
4
class BleSensor
5
{
6
};
7
8
#endif //  BLE_SENSOR_H

1
public:
2
    BleSensor();
3
    void scanAndConnect();

1
private:
2
    std::unique_ptr<sdbus::IProxy> bluezProxy;

1
#include <sdbus-c++/sdbus-c++.h>

1
#include "BleSensor.h"

1
BleSensor::BleSensor()
2
{
3
    const std::string SERVICE_BLUEZ { "org.bluez" };
4
    const std::string OBJECT_PATH { "/org/bluez/hci0" };
5
6
    bluezProxy = sdbus::createProxy(SERVICE_BLUEZ, OBJECT_PATH);
7
}

1
bool getBluetoothStatus();

1
bool BleSensor::getBluetoothStatus()
2
{
3
    const std::string METHOD_GET { "Get" };
4
    const std::string INTERFACE_PROPERTIES { "org.freedesktop.DBus.Properties" };
5
    const std::string INTERFACE_ADAPTER { "org.bluez.Adapter1" };
6
    const std::string PROPERTY_POWERED { "Powered" };
7
    sdbus::Variant variant;
8
9
    // Invoke a method that gets a property as a variant
10
    bluezProxy->callMethod(METHOD_GET)
11
        .onInterface(INTERFACE_PROPERTIES)
12
        .withArguments(INTERFACE_ADAPTER, PROPERTY_POWERED)
13
        .storeResultsTo(variant);
14
15
    return (bool)variant;
16
}

1
void BleSensor::scanAndConnect()
2
{
3
    try
4
    {
5
        // Enable Bluetooth if not yet enabled
6
        if (getBluetoothStatus())
7
        {
8
            std::cout << "Bluetooth powered ON\n";
9
        } else
10
        {
11
            std::cout << "Powering bluetooth ON\n";
12
        }
13
    }
14
    catch(sdbus::Error& error)
15
    {
16
        std::cerr << "ERR: on scanAndConnect(): " << error.getName() << " with message " << error.getMessage() << std::endl;
17
    }
18
}

1
#include <iostream>

1
file(GLOB SOURCES "*.cpp")
2
add_executable(${PROJECT_NAME} ${SOURCES})

1
#include "BleSensor.h"
2
3
int main(int argc, char *argv[])
4
{
5
    std::cout << "Noise Collector BLE" << std::endl;
6
    BleSensor bleSensor;
7
    bleSensor.scanAndConnect();

1
void setBluetoothStatus(bool enable);

1
void BleSensor::setBluetoothStatus(bool enable)
2
{
3
    // Invoke a method that sets a property as a variant
4
    bluezProxy->callMethod(METHOD_SET)
5
        .onInterface(INTERFACE_PROPERTIES)
6
        .withArguments(INTERFACE_ADAPTER, PROPERTY_POWERED, sdbus::Variant(enable))
7
        // .dontExpectReply();
8
        .storeResultsTo();
9
}

1
const std::string METHOD_SET { "Set" };

1
static const std::string INTERFACE_ADAPTER { "org.bluez.Adapter1" };
2
static const std::string PROPERTY_POWERED { "Powered" };
3
static const std::string INTERFACE_PROPERTIES { "org.freedesktop.DBus.Properties" };

1
if (getBluetoothStatus())
2
{
3
    std::cout << "Bluetooth powered ON\n";
4
} else
5
{
6
    std::cout << "Powering bluetooth ON\n";
7
    setBluetoothStatus(true);
8
}

1
void enableScanning(bool enable);

1
void BleSensor::enableScanning(bool enable)
2
{
3
    const std::string METHOD_START_DISCOVERY { "StartDiscovery" };
4
    const std::string METHOD_STOP_DISCOVERY { "StopDiscovery" };
5
6
    std::cout << (enable?"Start":"Stop") << " scanning\n";
7
    bluezProxy->callMethod(enable?METHOD_START_DISCOVERY:METHOD_STOP_DISCOVERY)
8
        .onInterface(INTERFACE_ADAPTER)
9
        .dontExpectReply();
10
}

1
enableScanning(true);
2
// Wait to be connected to the sensor
3
enableScanning(false);

1
// Wait to be connected to the sensor
2
std::this_thread::sleep_for(std::chrono::seconds(10))

1
#include <chrono>
2
#include <thread>

1
std::unique_ptr<sdbus::IProxy> rootProxy;

1
rootProxy = sdbus::createProxy(SERVICE_BLUEZ, "/");

1
void subscribeToInterfacesAdded();

1
void BleSensor::subscribeToInterfacesAdded()
2
{
3
    const std::string INTERFACE_OBJ_MGR { "org.freedesktop.DBus.ObjectManager" };
4
    const std::string MEMBER_IFACE_ADDED { "InterfacesAdded" };
5
6
    // Let's subscribe for the interfaces added signals (AddMatch)
7
    rootProxy->uponSignal(MEMBER_IFACE_ADDED).onInterface(INTERFACE_OBJ_MGR).call(interfaceAddedCallback);
8
    rootProxy->finishRegistration();
9
}

1
auto interfaceAddedCallback = [this](sdbus::ObjectPath path,
2
                                     std::map<std::string,
3
                                     std::map<std::string, sdbus::Variant>> dictionary)
4
{
5
};

1
const std::regex DEVICE_INSTANCE_RE{"^/org/bluez/hci[0-9]/dev(_[0-9A-F]{2}){6}$"};
2
std::smatch match;
3
std::cout << "(TID: " << std::this_thread::get_id() << ") ";
4
if (std::regex_match(path, match, DEVICE_INSTANCE_RE)) {
5
    std::cout << "Device iface ";
6
7
    if (dictionary["org.bluez.Device1"].count("Name") == 1)
8
    {
9
        auto name = (std::string)(dictionary["org.bluez.Device1"].at("Name"));
10
        std::cout << name << " @ " << path << std::endl;
11
    } else
12
    {
13
        std::cout << "<NAMELESS> @ " << path << std::endl;
14
    }
15
} else {
16
    std::cout << "*** UNEXPECTED SIGNAL ***";
17
}

1
#include <regex>

1
subscribeToInterfacesAdded();

1
std::cout << "(TID: " << std::this_thread::get_id() << ") ";

1
void connectToDevice(sdbus::ObjectPath path);

1
BleSensor(const std::string &sensor_name);

1
const std::string deviceName;

1
std::unique_ptr<sdbus::IProxy> deviceProxy;

1
BleSensor::BleSensor(const std::string &sensor_name)
2
    : deviceProxy{nullptr}, deviceName{sensor_name}

1
void BleSensor::connectToDevice(sdbus::ObjectPath path)
2
{
3
}

1
deviceProxy = sdbus::createProxy(SERVICE_BLUEZ, path);

1
inline static const std::string SERVICE_BLUEZ{"org.bluez"};

1
deviceProxy->callMethodAsync(METHOD_CONNECT).onInterface(INTERFACE_DEVICE).uponReplyInvoke(connectionCallback);
2
std::cout << "Connection method started" << std::endl;

1
const std::string INTERFACE_DEVICE{"org.bluez.Device1"};
2
const std::string METHOD_CONNECT{"Connect"};

1
auto connectionCallback = [this](const sdbus::Error *error)
2
{
3
};

1
if (name == deviceName)
2
{
3
    std::cout << "Connecting to " << name << std::endl;
4
    connectToDevice(path);
5
}

1
std::mutex mtx;
2
std::condition_variable cv;
3
bool connected;

1
#include <condition_variable>

1
BleSensor::BleSensor(const std::string &sensor_name)
2
    : deviceProxy{nullptr}, deviceName{sensor_name},
3
      cv{}, mtx{}, connected{false}

1
std::unique_lock<std::mutex> lock(mtx);

1
enableScanning(true);
2
// Wait to be connected to the sensor
3
cv.wait(lock, [this]()
4
        { return connected; });
5
enableScanning(false);

1
if (error != nullptr)
2
{
3
    std::cerr << "Got connection error "
4
              << error->getName() << " with message "
5
              << error->getMessage() << std::endl;
6
    return;
7
}

1
std::unique_lock<std::mutex> lock(mtx);
2
std::cout << "Connected!!!" << std::endl;
3
connected = true;
4
lock.unlock();
5
cv.notify_one();
6
std::cout << "Finished connection method call" << std::endl;

1
BleSensor bleSensor { "RP2-SENSOR" };

1
if (!connected)
2
{
3
    // Current code with regex goes here.
4
}
5
else
6
{
7
}

1
if (std::regex_match(path, match, DEVICE_ATTRS_RE))
2
{
3
}
4
else
5
{
6
    std::cout << "Not a characteristic" << std::endl;
7
}

1
const std::regex DEVICE_ATTRS_RE{"^/org/bluez/hci\\d/dev(_[0-9A-F]{2}){6}/service\\d{4}/char\\d{4}"};

1
std::cout << "Characteristic " << path << std::endl;
2
if ((dictionary.count("org.bluez.GattCharacteristic1") == 1) &&
3
    (dictionary["org.bluez.GattCharacteristic1"].count("UUID") == 1))
4
{
5
    auto name = (std::string)(dictionary["org.bluez.GattCharacteristic1"].at("UUID"));
6
    if (name == "00002a1c-0000-1000-8000-00805f9b34fb")
7
    {
8
    }
9
}

1
tempAttrProxy = sdbus::createProxy(SERVICE_BLUEZ, path);
2
std::cout << "<<<FOUND>>> " << path << std::endl;

1
std::unique_ptr<sdbus::IProxy> tempAttrProxy;

1
BleSensor::BleSensor(const std::string &sensor_name)
2
    : deviceProxy{nullptr}, tempAttrProxy{nullptr},
3
      cv{}, mtx{}, connected{false}, deviceName{sensor_name}

1
void getValue();

1
void readTemperature();

1
void BleSensor::getValue()
2
{
3
    readTemperature();
4
}

1
void BleSensor::readTemperature()
2
{
3
    tempAttrProxy->callMethod(METHOD_READ)
4
        .onInterface(INTERFACE_CHAR)
5
        .withArguments(args)
6
        .storeResultsTo(result);
7
}

1
const std::string INTERFACE_CHAR{"org.bluez.GattCharacteristic1"};
2
const std::string METHOD_READ{"ReadValue"};

1
std::map<std::string, sdbus::Variant> args{{{"offset", sdbus::Variant{std::uint16_t{0}}}}};
2
std::vector<std::uint8_t> result;

1
std::cout << "READ: ";
2
for (auto value : result)
3
{
4
    std::cout << +value << " ";
5
}
6
std::vector number(result.begin() + 1, result.end());

1
float valueFromIeee11073(std::vector<std::uint8_t> binary);

1
float BleSensor::valueFromIeee11073(std::vector<std::uint8_t> binary)
2
{
3
    float value = static_cast<float>(binary[0]) + static_cast<float>(binary[1]) * 256.f + static_cast<float>(binary[2]) * 256.f * 256.f;
4
    float exponent;
5
    if (binary[3] > 127)
6
    {
7
        exponent = static_cast<float>(binary[3]) - 256.f;
8
    }
9
    else
10
    {
11
        exponent = static_cast<float>(binary[3]);
12
    }
13
    return value * pow(10, exponent);
14
}

1
#include <cmath>

1
std::cout << "\nTemp: " << valueFromIeee11073(number);
2
std::cout << std::endl;

1
std::this_thread::sleep_for(std::chrono::seconds(5));
2
bleSensor.getValue();
3
std::this_thread::sleep_for(std::chrono::seconds(5));

1
#include <thread>

1
void disconnect();

1
void disconnectFromDevice();

1
void BleSensor::disconnectFromDevice()
2
{
3
    const std::string INTERFACE_DEVICE{"org.bluez.Device1"};
4
    const std::string METHOD_DISCONNECT{"Disconnect"};
5
6
    auto disconnectionCallback = [this](const sdbus::Error *error)
7
    {
8
    };
9
10
    {
11
        deviceProxy->callMethodAsync(METHOD_DISCONNECT).onInterface(INTERFACE_DEVICE).uponReplyInvoke(disconnectionCallback);
12
        std::cout << "Disconnection method started" << std::endl;
13
    }
14
}

1
if (error != nullptr)
2
{
3
    std::cerr << "Got disconnection error " << error->getName() << " with message " << error->getMessage() << std::endl;
4
    return;
5
}
6
std::unique_lock<std::mutex> lock(mtx);
7
std::cout << "Disconnected!!!" << std::endl;
8
connected = false;
9
deviceProxy = nullptr;
10
lock.unlock();
11
std::cout << "Finished connection method call" << std::endl;

1
void BleSensor::disconnect()
2
{
3
    std::cout << "Disconnecting from device" << std::endl;
4
    disconnectFromDevice();
5
}

1
bleSensor.disconnect();