cs_Stack.h

Go to the documentation of this file.

 
#pragma once
 
#include <ble/cs_Nordic.h>
#include <ble/cs_Service.h>
#include <ble/cs_UUID.h>
#include <cfg/cs_Config.h>
#include <cfg/cs_Strings.h>
#include <common/cs_BaseClass.h>
#include <common/cs_Tuple.h>
#include <common/cs_Types.h>
#include <drivers/cs_Timer.h>
#include <third/std/function.h>
#include <util/cs_BleError.h>
 
#include <string>
 
 
class Service;
 
class Stack : public BaseClass<3> {
public:
    static Stack& getInstance() {
        static Stack instance;
        return instance;
    }
 
    static const uint8_t MAX_SERVICE_COUNT = 5;
    typedef fixed_tuple<Service*, MAX_SERVICE_COUNT> Services_t;
 
    enum condition_t { C_STACK_INITIALIZED, C_RADIO_INITIALIZED, C_SERVICES_INITIALIZED };
 
protected:
    bool _disconnectingInProgress = false;
 
    // might want to change this to a linked list or something that
    // we can loop over but doesn't allocate more space than needed
    Services_t _services;
 
    nrf_clock_lf_cfg_t _clockSource;
    ble_gap_conn_params_t _connectionParams;
 
    bool _scanning             = false;
 
    uint16_t _connectionHandle = BLE_CONN_HANDLE_INVALID;
    bool _connectionIsOutgoing = false;
 
    app_timer_t _connectionWatchdogTimerData;
    app_timer_id_t _connectionWatchdogTimerId = NULL;
    bool _connectionWatchdogRunning           = false;
 
    uint8_t _scanBuffer[31];  // Same size as buffer in cs_stack_scan_t.
    ble_data_t _scanBufferStruct = {_scanBuffer, sizeof(_scanBuffer)};
 
public:
    void init();
 
    void initRadio();
 
    void initSoftdevice();
 
    void createCharacteristics();
 
    bool isDisconnecting();
 
    bool isConnected();
 
    bool isConnectedPeripheral();
 
    void resetConnectionWatchdog();
 
    uint16_t getConnectionHandle() { return _connectionHandle; }
 
    void setClockSource(nrf_clock_lf_cfg_t clockSource);
 
    void updateMinConnectionInterval(uint16_t connectionInterval_1_25_ms);
 
    void updateMaxConnectionInterval(uint16_t connectionInterval_1_25_ms);
 
    void updateSlaveLatency(uint16_t slaveLatency);
 
    void updateConnectionSupervisionTimeout(uint16_t conSupTimeout_10_ms);
 
    void addService(Service* svc);
 
    void initServices();
 
    void startScanning();
 
    void stopScanning();
 
    bool isScanning();
 
    void onBleEvent(const ble_evt_t* p_ble_evt);
 
    void onBleEventInterrupt(const ble_evt_t* p_ble_evt, bool isInterrupt);
 
    void secReqTimeoutHandler(void* p_context);
    void disconnect();
 
    bool checkCondition(condition_t condition, bool expectation);
 
protected:
    void updateConnParams();
 
    void onConnect(const ble_evt_t* p_ble_evt);
    void onDisconnect(const ble_evt_t* p_ble_evt);
    void onGapTimeout(uint8_t src);
 
    void onConnectionTimeout();
 
    void onIncomingConnected(const ble_evt_t* p_ble_evt);
    void onIncomingDisconnected(const ble_evt_t* p_ble_evt);
 
    void onMemoryRequest(uint16_t connectionHandle);
    void onMemoryRelease(uint16_t connectionHandle);
 
    void onWrite(uint16_t connectionHandle, const ble_gatts_evt_write_t& writeEvt);
 
    void onTxComplete(const ble_evt_t* p_ble_evt);
 
    void startConnectionWatchdog();
    void stopConnectionWatchdog();
 
private:
    Stack();
    Stack(Stack const&);
    void operator=(Stack const&);
 
    ~Stack();
};