cs_BleCentral.h

Go to the documentation of this file.

/*
 * Author: Crownstone Team
 * Copyright: Crownstone (https://crownstone.rocks)
 * Date: Mar 26, 2021
 * License: LGPLv3+, Apache License 2.0, and/or MIT (triple-licensed)
 */
 
#pragma once
 
#include <ble/cs_Nordic.h>
#include <ble/cs_UUID.h>
#include <common/cs_Types.h>
#include <events/cs_Event.h>
#include <events/cs_EventListener.h>
#include <structs/cs_PacketsInternal.h>
 
class BleCentral : EventListener {
public:
    static BleCentral& getInstance() {
        static BleCentral instance;
        return instance;
    }
 
    void init();
 
    cs_ret_code_t connect(const device_address_t& address, uint16_t timeoutMs = 3000);
 
    cs_ret_code_t disconnect();
 
    cs_ret_code_t discoverServices(const UUID* uuids, uint8_t uuidCount);
 
    cs_ret_code_t read(uint16_t handle);
 
    cs_ret_code_t write(uint16_t handle, const uint8_t* data, uint16_t len);
 
    cs_ret_code_t writeNotificationConfig(uint16_t cccdHandle, bool enableNotifications);
 
    cs_data_t requestWriteBuffer();
 
    bool isConnected();
 
    bool isBusy();
 
private:
    enum class Operation : uint8_t {
        NONE,
        CONNECT_CLEARANCE,  // Waiting for clearance to connect.
        CONNECT,
        DISCONNECT,
        DISCOVERY,
        READ,
        WRITE
    };
 
    BleCentral();
    BleCentral(BleCentral const&);
    void operator=(BleCentral const&);
 
    device_address_t _address;
 
    uint16_t _timeoutMs;
 
    cs_data_t _buf;
 
    uint16_t _bufDataSize      = 0;
 
    uint16_t _connectionHandle = BLE_CONN_HANDLE_INVALID;
 
    uint16_t _currentHandle    = BLE_GATT_HANDLE_INVALID;
 
    ble_db_discovery_t _discoveryModule;
 
#if NORDIC_SDK_VERSION > 15
    ble_db_discovery_init_t _discoveryInit;
 
    nrf_ble_gq_t* _queue;
#endif
 
    uint16_t _mtu               = BLE_GATT_ATT_MTU_DEFAULT;
 
    Operation _currentOperation = Operation::NONE;
 
    TYPIFY(CONFIG_SCAN_INTERVAL_625US) _scanInterval;
    TYPIFY(CONFIG_SCAN_WINDOW_625US) _scanWindow;
 
    cs_ret_code_t connectWithClearance(const device_address_t& address, uint16_t timeoutMs = 3000);
 
    cs_ret_code_t nextWrite(uint16_t handle, uint16_t offset);
 
    void finalizeOperation(Operation operation, cs_ret_code_t retCode);
    void finalizeOperation(Operation operation, uint8_t* data, uint8_t dataSize);
    void sendOperationResult(event_t& event);
 
    void onGapEvent(uint16_t evtId, const ble_gap_evt_t& event);
    void onGattCentralEvent(uint16_t evtId, const ble_gattc_evt_t& event);
 
    void onConnectClearance();
    void onConnect(uint16_t connectionHandle, const ble_gap_evt_connected_t& event);
    void onDisconnect(const ble_gap_evt_disconnected_t& event);
    void onGapTimeout(const ble_gap_evt_timeout_t& event);
 
    void onMtu(uint16_t gattStatus, const ble_gattc_evt_exchange_mtu_rsp_t& event);
    void onRead(uint16_t gattStatus, const ble_gattc_evt_read_rsp_t& event);
    void onWrite(uint16_t gattStatus, const ble_gattc_evt_write_rsp_t& event);
    void onNotification(uint16_t gattStatus, const ble_gattc_evt_hvx_t& event);
 
public:
    void onBleEvent(const ble_evt_t* event);
 
    void onDiscoveryEvent(ble_db_discovery_evt_t& event);
 
    void handleEvent(event_t& event);
};