NimBLEWrapper.hpp

Go to the documentation of this file.

 
#pragma once
 
//------------------------------------------------------------------------------
// Conditional compilation
//------------------------------------------------------------------------------
 
#include <sdkconfig.h> // For conditional compilation
#include "SimWheelInternals.hpp" // BatteryStatusChrData
 
#if CONFIG_NIMBLE_ENABLED
 
//------------------------------------------------------------------------------
// Imports
//------------------------------------------------------------------------------
 
#include <cstdint>
#include <string>
#include <functional>
#include <initializer_list>
#include <type_traits>
 
#include "host/ble_att.h"  // ATT layer
#include "host/ble_gatt.h" // GATT layer
#include "host/ble_uuid.h" // UUIDs
#include "host/ble_gap.h"  // GAP layer
#include "host/ble_gap.h"  // GAP layer
#include "os/os_mbuf.h"    // Attribute buffers
#include "esp32-hal-log.h" // Logging
 
#include "HID_definitions.hpp"
 
//------------------------------------------------------------------------------
// Constants
//------------------------------------------------------------------------------
 
#define HID_REPORT_COUNT 10
 
#define EMPTY_ble_gatt_cpfd { \
    .format = 0,              \
    .exponent = 0,            \
    .unit = 0,                \
    .name_space = 0,          \
    .description = 0}
 
#define EMPTY_ble_gatt_dsc_def { \
    .uuid = nullptr,             \
    .att_flags = 0,              \
    .min_key_size = 0,           \
    .access_cb = nullptr,        \
    .arg = nullptr}
 
#define EMPTY_ble_gatt_chr_def { \
    .uuid = nullptr,             \
    .access_cb = nullptr,        \
    .arg = nullptr,              \
    .descriptors = nullptr,      \
    .flags = 0,                  \
    .min_key_size = 0,           \
    .val_handle = nullptr,       \
    .cpfd = nullptr}
 
#define EMPTY_ble_gatt_svc_def { \
    .type = 0,                   \
    .uuid = nullptr,             \
    .includes = nullptr,         \
    .characteristics = nullptr}
 
//------------------------------------------------------------------------------
// Classes
//------------------------------------------------------------------------------
 
struct ApiResult
{
    int code = 0;
    constexpr ApiResult() noexcept {};
    constexpr ApiResult(int value) noexcept : code{value} {};
    constexpr ApiResult(const ApiResult &) noexcept = default;
    constexpr ApiResult(ApiResult &&) noexcept = default;
 
    constexpr operator bool() const noexcept { return (code == 0); }
 
    constexpr explicit operator int() const noexcept { return code; }
 
    constexpr ApiResult &operator=(const ApiResult &) noexcept = default;
 
    constexpr ApiResult &operator=(ApiResult &&) noexcept = default;
 
    constexpr ApiResult &operator=(int value) noexcept;
 
    void abort_if(const char *txt) const;
 
    void log_if(const char *txt) const noexcept;
 
    int to_attr_rc(bool readOrWrite) const noexcept;
}; // ApiResult
 
struct BLEAdvertising
{
    friend struct BLEDevice;
 
    using OnConnectionStatus = ::std::function<void(bool)>;
 
    inline static OnConnectionStatus onConnectionStatus;
 
    static void start();
 
    static void stop() noexcept;
 
    static bool connected() noexcept { return _connected; }
 
    static void disconnect() noexcept;
 
private:
    inline static const ble_gap_adv_params adv_params{
        .conn_mode = BLE_GAP_CONN_MODE_UND, // Undirected, connectable
        .disc_mode = BLE_GAP_DISC_MODE_GEN, // General discoverable
        .itvl_min = 0,
        .itvl_max = 0,
        .channel_map = 0,
        .filter_policy = 0,
        .high_duty_cycle = 0,
    };
 
    inline static bool _connected = false;
 
    inline static int16_t _conn_handle = BLE_HS_CONN_HANDLE_NONE;
 
    static int ble_gap_event_fn(ble_gap_event *event, void *arg);
 
    static void init();
}; // struct BLEAdvertising
 
struct BLEDevice
{
    friend class BLEAdvertising;
 
    static bool initialized() { return _initialized; };
 
    static void init(const std::string &deviceName);
 
private:
    inline static uint8_t address_type = 0;
 
    inline static bool ready = false;
 
    inline static bool _initialized = false;
 
    static void init_gatt_server();
 
    static void onReset(int reason);
 
    static void onSync();
 
    static void host_task(void *param);
}; // struct BLEDevice
 
struct BLEReadCallback
{
    virtual int onRead(os_mbuf *buffer) { return 0; };
};
 
struct BLEWriteCallback
{
    virtual int onWrite(void *data, uint16_t data_size) { return 0; };
};
 
template <
    typename T,
    bool is_descriptor = false>
struct BLEAccessor
{
    static constexpr bool can_read =
        ::std::is_base_of<BLEReadCallback, T>::value;
    static constexpr bool can_write =
        ::std::is_base_of<BLEWriteCallback, T>::value;
 
    static_assert(
        can_read || can_write,
        "BLE: Accessor does not read or write");
 
    static int access_fn(
        uint16_t conn_handle,
        uint16_t attr_handle,
        ble_gatt_access_ctxt *ctxt,
        void *arg)
    {
        assert(arg);
        log_d(
            "BLEAccessor::access_fn(%d,%d,...), op=%d",
            conn_handle,
            attr_handle,
            ctxt->op);
        if constexpr (can_read)
        {
            if constexpr (is_descriptor)
            {
                if (ctxt->op == BLE_GATT_ACCESS_OP_READ_DSC)
                    return static_cast<T *>(arg)->onRead(ctxt->om);
            }
            else
            {
                if (ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR)
                    return static_cast<T *>(arg)->onRead(ctxt->om);
            }
            log_e("Unexpected READ operation on attr_handle %d", attr_handle);
        }
        if constexpr (can_write)
        {
 
            if constexpr (is_descriptor)
            {
                if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_DSC)
                    return static_cast<T *>(arg)->onWrite(ctxt->om);
            }
            else
            {
                if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR)
                    return static_cast<T *>(arg)->onWrite(
                        ctxt->om->om_data,
                        ctxt->om->om_len);
            }
            log_e("Unexpected WRITE operation on attr_handle %d", attr_handle);
        }
        return BLE_ATT_ERR_UNLIKELY;
    }
};
 
enum class HIDReportType : uint8_t
{
    input = 1,
    output = 2,
    feature = 3
};
 
struct BLEDesc2908 : BLEReadCallback
{
 
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x2908);
 
    ble_gatt_dsc_def definition();
 
    void set(uint8_t report_id, HIDReportType report_type);
 
    virtual int onRead(os_mbuf *buffer) override;
 
    uint8_t report_id() { return _report_id; }
 
    HIDReportType report_type() { return _report_type; }
 
private:
    HIDReportType _report_type = HIDReportType::feature;
    uint8_t _report_id = 0;
}; // BLEDesc2908
 
struct BLECharacteristic
{
    static constexpr const uint16_t INVALID_HANDLE = 0xFFFF;
    virtual ble_gatt_chr_def definition() = 0;
 
    void notify() const;
 
    void setSubscription_if(uint16_t requested_attr_handle, bool status);
 
protected:
    bool subscribed = false;
    uint16_t attr_handle = INVALID_HANDLE;
};
 
struct BatteryLevelChr : BLECharacteristic, BLEReadCallback
{
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x2A19);
 
    virtual int onRead(os_mbuf *buffer) override;
    virtual ble_gatt_chr_def definition() override;
 
    void set(uint8_t new_value);
 
    uint8_t get() const noexcept { return value; }
 
private:
    inline static ble_gatt_cpfd _chr_cpfd_def[]{
        {
            .format = 4, // uint8
            .exponent = 0,
            .unit = 0x27AD,       // percentage
            .name_space = 0x01,   // Bluetooth SIG
            .description = 0x106, // main namespace
        },
        EMPTY_ble_gatt_cpfd,
    };
    uint8_t value{100};
    ble_gatt_dsc_def dsc_def[2]{};
};
 
struct BatteryStatusChr : BLECharacteristic, BLEReadCallback
{
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x2BED);
 
    virtual int onRead(os_mbuf *buffer) override;
    virtual ble_gatt_chr_def definition() override;
 
    void set(const BatteryStatusChrData &new_value);
 
private:
    BatteryStatusChrData value{};
};
 
struct BLEBatteryService
{
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x180F);
 
    inline static BatteryLevelChr batteryLevel{};
    inline static BatteryStatusChr batteryStatus{};
 
    static const ble_gatt_svc_def definition();
 
    static void init();
 
    static void onSubscriptionChange(
        uint16_t attr_handle,
        bool yesOrNo)
    {
        batteryLevel.setSubscription_if(attr_handle, yesOrNo);
        batteryStatus.setSubscription_if(attr_handle, yesOrNo);
    }
 
private:
    inline static ble_gatt_chr_def chr_set[3]{};
};
 
struct PnpInfoChr : BLECharacteristic, BLEReadCallback
{
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x2A50);
 
    uint16_t vid = BLE_VENDOR_ID;
    uint16_t pid = BLE_PRODUCT_ID;
 
    virtual int onRead(os_mbuf *buffer) override;
    virtual ble_gatt_chr_def definition() override;
};
 
struct SerialNumberChr : BLECharacteristic, BLEReadCallback
{
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x2A25);
 
    virtual int onRead(os_mbuf *buffer) override;
    virtual ble_gatt_chr_def definition() override;
};
 
struct ManufacturerChr : BLECharacteristic, BLEReadCallback
{
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x2A29);
    ::std::string name{};
 
    virtual int onRead(os_mbuf *buffer) override;
    virtual ble_gatt_chr_def definition() override;
};
 
struct BLEDeviceInfoService
{
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x180A);
 
    inline static PnpInfoChr pnpInfo;
 
    inline static SerialNumberChr serialNumber;
 
    inline static ManufacturerChr manufacturer;
 
    static const ble_gatt_svc_def definition();
 
    static void init();
 
private:
    inline static ble_gatt_chr_def chr_set[4]{};
};
 
struct HIDReportChr : BLECharacteristic
{
    friend class BLEHIDService;
 
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x2A4D);
 
protected:
    BLEDesc2908 desc2908;
    ble_gatt_dsc_def desc_def[2]{};
    size_t report_size = 0;
};
 
struct FeatureReportChr : HIDReportChr
{
    FeatureReportChr(uint8_t report_id, size_t size) noexcept;
    FeatureReportChr(const FeatureReportChr &) noexcept = default;
    FeatureReportChr(FeatureReportChr &&) noexcept = default;
    FeatureReportChr &operator=(const FeatureReportChr &) noexcept = default;
    FeatureReportChr &operator=(FeatureReportChr &&) noexcept = default;
 
    virtual ble_gatt_chr_def definition() override;
};
 
struct OutputReportChr : HIDReportChr
{
    OutputReportChr(uint8_t report_id, size_t size) noexcept;
    OutputReportChr(const OutputReportChr &) noexcept = default;
    OutputReportChr(OutputReportChr &&) noexcept = default;
    OutputReportChr &operator=(const OutputReportChr &) noexcept = default;
    OutputReportChr &operator=(OutputReportChr &&) noexcept = default;
 
    virtual ble_gatt_chr_def definition() override;
};
 
struct InputReportChr : HIDReportChr
{
    InputReportChr(uint8_t report_id, size_t size) noexcept;
    InputReportChr(const InputReportChr &) noexcept = default;
    InputReportChr(InputReportChr &&) noexcept = default;
    InputReportChr &operator=(const InputReportChr &) noexcept = default;
    InputReportChr &operator=(InputReportChr &&) noexcept = default;
    virtual ble_gatt_chr_def definition() override;
};
 
struct HIDInfoChr : BLECharacteristic, BLEReadCallback
{
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x2A4A);
 
    virtual int onRead(os_mbuf *buffer) override;
    virtual ble_gatt_chr_def definition() override;
};
 
struct HIDControlChr : BLECharacteristic, BLEWriteCallback
{
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x2A4C);
 
    virtual ble_gatt_chr_def definition() override;
};
 
struct HIDReportMapChr : BLECharacteristic, BLEReadCallback
{
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x2A4B);
 
    virtual int onRead(os_mbuf *buffer) override;
    virtual ble_gatt_chr_def definition() override;
};
 
// TO-DO
// - Consider return BLE_ATT_ERR_VALUE_NOT_ALLOWED on write attempts
//   as "boot mode" does not make sense in this device
// - Check if this characteristic is mandatory or not
 
struct HIDProtocolModeChr : BLECharacteristic, BLEReadCallback, BLEWriteCallback
{
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x2A4E);
 
    virtual int onRead(os_mbuf *buffer) override;
    virtual int onWrite(void *data, uint16_t data_size) override;
    virtual ble_gatt_chr_def definition() override;
 
private:
    uint8_t value = 0x01; // Non-boot mode
};
 
struct BLEHIDService
{
    friend class FeatureReportChr;
    friend class OutputReportChr;
    friend class InputReportChr;
 
    inline static const ble_uuid16_t uuid = BLE_UUID16_INIT(0x1812);
 
    using OnGetFeatureCallback =
        // params(reportID,[out]data,data_size)
        // return count of bytes written into "data"
        ::std::function<uint16_t(uint8_t, uint8_t *, uint16_t)>;
    using OnSetFeatureCallback =
        // params(reportID,data,data_size)
        ::std::function<void(uint8_t, const uint8_t *, uint16_t)>;
    using OnOutputCallback = OnSetFeatureCallback;
    using OnInputCallback = OnGetFeatureCallback;
 
    inline static OnGetFeatureCallback onGetFeatureReport = nullptr;
    inline static OnSetFeatureCallback onSetFeatureReport = nullptr;
    inline static OnOutputCallback onWriteOutputReport = nullptr;
    inline static OnInputCallback onReadInputReport = nullptr;
 
    inline static HIDInfoChr info;
    inline static HIDControlChr control;
    inline static HIDReportMapChr report_map;
    inline static HIDProtocolModeChr protocol_mode;
 
    inline static InputReportChr input_report{
        RID_INPUT_GAMEPAD,
        GAMEPAD_REPORT_SIZE};
    inline static FeatureReportChr capabilities_report{
        RID_FEATURE_CAPABILITIES,
        CAPABILITIES_REPORT_SIZE};
    inline static FeatureReportChr config_report{
        RID_FEATURE_CONFIG,
        CONFIG_REPORT_SIZE};
    inline static FeatureReportChr button_map_report{
        RID_FEATURE_BUTTONS_MAP,
        BUTTONS_MAP_REPORT_SIZE};
    inline static FeatureReportChr hardware_id_report{
        RID_FEATURE_HARDWARE_ID,
        HARDWARE_ID_REPORT_SIZE};
    inline static OutputReportChr powertrain_report{
        RID_OUTPUT_POWERTRAIN,
        POWERTRAIN_REPORT_SIZE};
    inline static OutputReportChr ecu_report{
        RID_OUTPUT_ECU,
        ECU_REPORT_SIZE};
    inline static OutputReportChr race_control_report{
        RID_OUTPUT_RACE_CONTROL,
        RACE_CONTROL_REPORT_SIZE};
    inline static OutputReportChr gauges_report{
        RID_OUTPUT_GAUGES,
        GAUGES_REPORT_SIZE};
    inline static OutputReportChr pixel_report{
        RID_OUTPUT_PIXEL,
        PIXEL_REPORT_SIZE};
 
    static const ble_gatt_svc_def definition();
 
    static void init();
 
    static void onSubscriptionChange(
        uint16_t attr_handle,
        bool yesOrNo)
    {
        input_report.setSubscription_if(attr_handle, yesOrNo);
    }
 
private:
    inline static ble_gatt_chr_def chr_set[4 + HID_REPORT_COUNT + 1]{};
    static int report_access_fn(
        uint16_t conn_handle,
        uint16_t attr_handle,
        ble_gatt_access_ctxt *ctxt,
        void *arg);
};
 
#endif // CONFIG_NIMBLE_ENABLED