[{
"resource": "/e:/esp32/esp32_spi_slave_transfer_Prj
(3
)/src/BLE_m
aster
.cpp",
"owner": "cpp",
"severity": 8,
"message": "'cl
ass NimBLEScan' h
as no mem
ber named 'setAdvertisedDeviceCallbacks'",
"startLineNum
ber": 30,
"startColumn": 12,
"endLineNum
ber": 30,
"endColumn": 12
},{
"resource": "/e:/esp32/esp32_spi_slave_transfer_Prj
(3
)/src/BLE_m
aster
.cpp",
"owner": "cpp",
"severity": 8,
"message": "'getClientListSize' is
not a mem
ber of 'NimBLEDevice'",
"startLineNum
ber": 40,
"startColumn": 36,
"endLineNum
ber": 40,
"endColumn": 36
},{
"resource": "/e:/esp32/esp32_spi_slave_transfer_Prj
(3
)/src/BLE_m
aster
.cpp",
"owner": "cpp",
"severity": 8,
"message": "'getClientByID' is
not a mem
ber of 'NimBLEDevice'",
"startLineNum
ber": 41,
"startColumn": 39,
"endLineNum
ber": 41,
"endColumn": 39
},{
"resource": "/e:/esp32/esp32_spi_slave_transfer_Prj
(3
)/src/BLE_m
aster
.cpp",
"owner": "cpp",
"severity": 8,
"message": "'cl
ass NimBLERemoteCharacteristic' h
as no mem
ber named 'set
NotifyCallback'; did you mean 'm_
notifyCallback'?",
"startLineNum
ber": 98,
"startColumn": 36,
"endLineNum
ber": 98,
"endColumn": 36
},{
"resource": "/e:/esp32/esp32_spi_slave_transfer_Prj
(3
)/src/BLE_m
aster
.cpp",
"owner": "cpp",
"severity": 8,
"message": "no match for 'operator=='
(operand types are 'std::__cxx11::
string' {aka 'std::__cxx11::b
asic_
string<char>'} and '
String'
)",
"startLineNum
ber": 127,
"startColumn": 36,
"endLineNum
ber": 127,
"endColumn": 36
}]
[{
"resource": "/e:/esp32/esp32_spi_slave_transfer_Prj
(3
)/src/BLE_m
aster
.h",
"owner": "cpp",
"severity": 8,
"message": "'void BLEM
aster::AdvertisedDeviceCallback::onResult
(NimBLEAdvertisedDevice
)' marked 'override', but does
not override",
"startLineNum
ber": 26,
"startColumn": 14,
"endLineNum
ber": 26,
"endColumn": 14
}]
/*
* Copyright 2020-2025 Ryan Powell <ryan@nable-em
bedded
.io> and
* esp-nimble-cpp, NimBLE-Arduino contributors
.
*
* Licensed under the Apache License, Version 2
.0
(the "License"
);
* you may
not use this file except in compliance with the License
.
* You may obtain a copy of the License at
*
* http://www
.apache
.org/licenses/LICENSE-2
.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "
AS IS" B
ASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
.
* See the License for the specific language governing permissions and
* limitations under the License
.
*/
#ifndef NIMBLE_CPP_DEVICE_H_
#define NIMBLE_CPP_DEVICE_H_
#include "nimconfig
.h"
#if CONFIG_BT_ENABLED
# ifdef ESP_PLATFORM
# ifndef CONFIG_IDF_TARGET_ESP32P4
# include <esp_bt
.h>
# endif
# endif
# if defined
(CONFIG_NIMBLE_CPP_IDF
)
# include <host/ble_gap
.h>
# else
# include <nimble/nimble/host/include/host/ble_gap
.h>
# endif
/**** FIX COMPILATION ****/
# undef min
# undef max
/**************************/
# include <
string>
# include <vector>
# if CONFIG_BT_NIMBLE_ROLE_CENTRAL
# include <array>
cl
ass NimBLEClient;
# endif
# if CONFIG_BT_NIMBLE_ROLE_OBSERVER
cl
ass NimBLEScan;
# endif
# if CONFIG_BT_NIMBLE_ROLE_BROADC
ASTER
# if CONFIG_BT_NIMBLE_EXT_ADV
cl
ass NimBLEExtAdvertising;
# else
cl
ass NimBLEAdvertising;
# endif
# endif
# if CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
cl
ass NimBLEServer;
# if CONFIG_BT_NIMBLE_L2CAP_COC_MAX_NUM > 0
cl
ass NimBLEL2CAPServer;
# endif
# endif
# if CONFIG_BT_NIMBLE_ROLE_PERIPHERAL || CONFIG_BT_NIMBLE_ROLE_CENTRAL
cl
ass NimBLEConnInfo;
# endif
cl
ass NimBLEAddress;
cl
ass NimBLEDeviceCallbacks;
# define BLEDevice NimBLEDevice
# define BLEClient NimBLEClient
# define BLERemoteService NimBLERemoteService
# define BLERemoteCharacteristic NimBLERemoteCharacteristic
# define BLERemoteDescriptor NimBLERemoteDescriptor
# define BLEAdvertisedDevice NimBLEAdvertisedDevice
# define BLEScan NimBLEScan
# define BLEUUID NimBLEUUID
# define BLEAddress NimBLEAddress
# define BLEUtils NimBLEUtils
# define BLEClientCallbacks NimBLEClientCallbacks
# define BLEAdvertisedDeviceCallbacks NimBLEScanCallbacks
# define BLEScanResults NimBLEScanResults
# define BLEServer NimBLEServer
# define BLEService NimBLEService
# define BLECharacteristic NimBLECharacteristic
# define BLEAdvertising NimBLEAdvertising
# define BLEServerCallbacks NimBLEServerCallbacks
# define BLECharacteristicCallbacks NimBLECharacteristicCallbacks
# define BLEAdvertisementData NimBLEAdvertisementData
# define BLEDescriptor NimBLEDescriptor
# define BLE2904 NimBLE2904
# define BLEDescriptorCallbacks NimBLEDescriptorCallbacks
# define BLE
Beacon NimBLE
Beacon
# define BLEEddystoneTLM NimBLEEddystoneTLM
# define BLEEddystoneURL NimBLEEddystoneURL
# define BLEConnInfo NimBLEConnInfo
# define BLEL2CAPServer NimBLEL2CAPServer
# define BLEL2CAPService NimBLEL2CAPService
# define BLEL2CAPServiceCallbacks NimBLEL2CAPServiceCallbacks
# define BLEL2CAPClient NimBLEL2CAPClient
# define BLEL2CAPClientCallbacks NimBLEL2CAPClientCallbacks
# define BLEL2CAPChannel NimBLEL2CAPChannel
# define BLEL2CAPChannelCallbacks NimBLEL2CAPChannelCallbacks
# ifdef CONFIG_BT_NIMBLE_MAX_CONNECTIONS
# define NIMBLE_MAX_CONNECTIONS CONFIG_BT_NIMBLE_MAX_CONNECTIONS
# else
# define NIMBLE_MAX_CONNECTIONS CONFIG_NIMBLE_MAX_CONNECTIONS
# endif
enum cl
ass NimBLETxPowerType { All = 0, Advertise = 1, Scan = 2, Connection = 3 };
typedef int
(*gap_event_handler
)(ble_gap_event* event, void* arg
);
/**
* @brief A model of a BLE Device from which all the BLE roles are
created.
*/
cl
ass NimBLEDevice {
public:
static bool init
(const std::
string& deviceName
);
static bool deinit
(bool clearAll = false
);
static bool setDeviceName
(const std::
string& deviceName
);
static bool isInitialized
();
static NimBLEAddress getAddress
();
static std::
string to
String();
static bool whiteListAdd
(const NimBLEAddress& address
);
static bool whiteListRemove
(const NimBLEAddress& address
);
static bool onWhiteList
(const NimBLEAddress& address
);
static size_t getWhiteListCount
();
static NimBLEAddress getWhiteListAddress
(size_t index
);
static bool setOwnAddrType
(uint8_t type
);
static bool setOwnAddr
(const NimBLEAddress& addr
);
static bool setOwnAddr
(const uint8_t* addr
);
static void setDeviceCallbacks
(NimBLEDeviceCallbacks* cb
);
static void setScanDuplicateCacheSize
(uint16_t cacheSize
);
static void setScanFilterMode
(uint8_t type
);
static void setScanDuplicateCacheResetTime
(uint16_t time
);
static bool setCustomGapHandler
(gap_event_handler handler
);
static void setSecurityAuth
(bool bonding, bool mitm, bool sc
);
static void setSecurityAuth
(uint8_t auth
);
static void setSecurityIOCap
(uint8_t iocap
);
static void setSecurityInitKey
(uint8_t initKey
);
static void setSecurityRespKey
(uint8_t respKey
);
static void setSecurityP
asskey
(uint32_t p
assKey
);
static uint32_t getSecurityP
asskey
();
static bool startSecurity
(uint16_t connHandle, int* rcPtr = nullptr
);
static bool setMTU
(uint16_t mtu
);
static uint16_t getMTU
();
static void onReset
(int re
ason
);
static void onSync
(void
);
static void host_t
ask
(void* param
);
static int getPower
(NimBLETxPowerType type = NimBLETxPowerType::All
);
static bool setPower
(int8_t dbm, NimBLETxPowerType type = NimBLETxPowerType::All
);
static bool setDefaultPhy
(uint8_t txPhyM
ask, uint8_t rxPhyM
ask
);
# ifdef ESP_PLATFORM
# ifndef CONFIG_IDF_TARGET_ESP32P4
static esp_power_level_t getPowerLevel
(esp_ble_power_type_t powerType = ESP_BLE_PWR_TYPE_DEFAULT
);
static bool setPowerLevel
(esp_power_level_t powerLevel, esp_ble_power_type_t powerType = ESP_BLE_PWR_TYPE_DEFAULT
);
# endif
# endif
# if CONFIG_BT_NIMBLE_ROLE_OBSERVER
static NimBLEScan* getScan
();
# endif
# if CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
static NimBLEServer* createServer
();
static NimBLEServer* getServer
();
# if CONFIG_BT_NIMBLE_L2CAP_COC_MAX_NUM > 0
static NimBLEL2CAPServer* createL2CAPServer
();
static NimBLEL2CAPServer* getL2CAPServer
();
# endif
# endif
# if CONFIG_BT_NIMBLE_ROLE_PERIPHERAL || CONFIG_BT_NIMBLE_ROLE_CENTRAL
static bool injectConfirmP
asskey
(const NimBLEConnInfo& peerInfo, bool accept
);
static bool injectP
assKey
(const NimBLEConnInfo& peerInfo, uint32_t pin
);
# endif
# if CONFIG_BT_NIMBLE_ROLE_BROADC
ASTER
# if CONFIG_BT_NIMBLE_EXT_ADV
static NimBLEExtAdvertising* getAdvertising
();
static bool startAdvertising
(uint8_t instId, int duration = 0, int maxEvents = 0
);
static bool stopAdvertising
(uint8_t instId
);
static bool stopAdvertising
();
# endif
# if !CONFIG_BT_NIMBLE_EXT_ADV || defined
(_DOXYGEN_
)
static NimBLEAdvertising* getAdvertising
();
static bool startAdvertising
(uint32_t duration = 0
);
static bool stopAdvertising
();
# endif
# endif
# if CONFIG_BT_NIMBLE_ROLE_CENTRAL
static NimBLEClient* createClient
();
static NimBLEClient* createClient
(const NimBLEAddress& peerAddress
);
static bool deleteClient
(NimBLEClient* pClient
);
static NimBLEClient* getClientByHandle
(uint16_t connHandle
);
static NimBLEClient* getClientByPeerAddress
(const NimBLEAddress& peerAddress
);
static NimBLEClient* getDisconnectedClient
();
static size_t get
CreatedClientCount
();
static std::vector<NimBLEClient*> getConnectedClients
();
# endif
# if CONFIG_BT_NIMBLE_ROLE_CENTRAL || CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
static bool deleteBond
(const NimBLEAddress& address
);
static int getNumBonds
();
static bool isBonded
(const NimBLEAddress& address
);
static bool deleteAllBonds
();
static NimBLEAddress getBondedAddress
(int index
);
# endif
private:
static bool m_synced;
static bool m_initialized;
static uint32_t m_p
asskey;
static ble_gap_event_listener m_listener;
static uint8_t m_ownAddrType;
static std::vector<NimBLEAddress> m_whiteList;
static NimBLEDeviceCallbacks* m_pDeviceCallbacks;
static NimBLEDeviceCallbacks defaultDeviceCallbacks;
# if CONFIG_BT_NIMBLE_ROLE_OBSERVER
static NimBLEScan* m_pScan;
# endif
# if CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
static NimBLEServer* m_pServer;
# if CONFIG_BT_NIMBLE_L2CAP_COC_MAX_NUM > 0
static NimBLEL2CAPServer* m_pL2CAPServer;
# endif
# endif
# if CONFIG_BT_NIMBLE_ROLE_BROADC
ASTER
# if CONFIG_BT_NIMBLE_EXT_ADV
static NimBLEExtAdvertising* m_bleAdvertising;
# else
static NimBLEAdvertising* m_bleAdvertising;
# endif
# endif
# if CONFIG_BT_NIMBLE_ROLE_CENTRAL
static std::array<NimBLEClient*, NIMBLE_MAX_CONNECTIONS> m_pClients;
# endif
# ifdef ESP_PLATFORM
# if CONFIG_BTDM_BLE_SCAN_DUPL || CONFIG_BT_LE_SCAN_DUPL
static uint16_t m_scanDuplicateSize;
static uint8_t m_scanFilterMode;
static uint16_t m_scanDuplicateResetTime;
# endif
# endif
# if CONFIG_BT_NIMBLE_ROLE_CENTRAL
friend cl
ass NimBLEClient;
# endif
# if CONFIG_BT_NIMBLE_ROLE_OBSERVER
friend cl
ass NimBLEScan;
# endif
# if CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
friend cl
ass NimBLEServer;
friend cl
ass NimBLECharacteristic;
# endif
# if CONFIG_BT_NIMBLE_ROLE_BROADC
ASTER
friend cl
ass NimBLEAdvertising;
# if CONFIG_BT_NIMBLE_EXT_ADV
friend cl
ass NimBLEExtAdvertising;
friend cl
ass NimBLEExtAdvertisement;
# endif
# endif
};
# if CONFIG_BT_NIMBLE_ROLE_CENTRAL
# include "NimBLEClient
.h"
# include "NimBLERemoteService
.h"
# include "NimBLERemoteCharacteristic
.h"
# include "NimBLERemoteDescriptor
.h"
# endif
# if CONFIG_BT_NIMBLE_ROLE_OBSERVER
# include "NimBLEScan
.h"
# endif
# if CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
# include "NimBLEServer
.h"
# include "NimBLEService
.h"
# include "NimBLECharacteristic
.h"
# include "NimBLEDescriptor
.h"
# if CONFIG_BT_NIMBLE_L2CAP_COC_MAX_NUM
# include "NimBLEL2CAPServer
.h"
# include "NimBLEL2CAPChannel
.h"
# endif
# endif
# if CONFIG_BT_NIMBLE_ROLE_BROADC
ASTER
# if CONFIG_BT_NIMBLE_EXT_ADV
# include "NimBLEExtAdvertising
.h"
# else
# include "NimBLEAdvertising
.h"
# endif
# endif
# if CONFIG_BT_NIMBLE_ROLE_CENTRAL || CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
# include "NimBLEConnInfo
.h"
# endif
# include "NimBLEAddress
.h"
# include "NimBLEUtils
.h"
/**
* @brief Callbacks
associated with a BLE device
.
*/
cl
ass NimBLEDeviceCallbacks {
public:
virtual ~NimBLEDeviceCallbacks
() {};
/**
* @brief Indicates an inability to perform a store operation
.
* This callback should do one of two things:
* -Address the problem and return 0, indicating that the store operation
* should proceed
.
* -Return nonzero to indicate that the store operation should
be aborted
.
* @param event Descri
bes the store event
being reported
.
* BLE_STORE_EVENT_FULL; or
* BLE_STORE_EVENT_OVERFLOW
* @return 0 if the store operation should proceed;
* nonzero if the store operation should
be aborted
.
*/
virtual int onStoreStatus
(struct ble_store_status_event* event, void* arg
);
};
#endif // CONFIG_BT_ENABLED
#endif // NIMBLE_CPP_DEVICE_H_
/*
* Copyright 2020-2025 Ryan Powell <ryan@nable-em
bedded
.io> and
* esp-nimble-cpp, NimBLE-Arduino contributors
.
*
* Licensed under the Apache License, Version 2
.0
(the "License"
);
* you may
not use this file except in compliance with the License
.
* You may obtain a copy of the License at
*
* http://www
.apache
.org/licenses/LICENSE-2
.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "
AS IS" B
ASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
.
* See the License for the specific language governing permissions and
* limitations under the License
.
*/
#ifndef NIMBLE_CPP_SCAN_H_
#define NIMBLE_CPP_SCAN_H_
#include "nimconfig
.h"
#if CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_OBSERVER
# include "NimBLEAdvertisedDevice
.h"
# include "NimBLEUtils
.h"
# if defined
(CONFIG_NIMBLE_CPP_IDF
)
# include "host/ble_gap
.h"
# else
# include "nimble/nimble/host/include/host/ble_gap
.h"
# endif
# include <vector>
cl
ass NimBLEDevice;
cl
ass NimBLEScan;
cl
ass NimBLEAdvertisedDevice;
cl
ass NimBLEScanCallbacks;
cl
ass NimBLEAddress;
/**
* @brief A cl
ass that contains and operates on the results of a BLE scan
.
* @details
When a scan completes, we have a set of found devices
. Each device is descri
bed
* by a NimBLEAdvertisedDevice object
. The num
ber of items in the set is given by
* getCount
(). We can retrieve a device by calling getDevice
() passing in the
* index
(starting at 0
) of the desired device
.
*/
cl
ass NimBLEScanResults {
public:
void dump
() const;
int getCount
() const;
const NimBLEAdvertisedDevice* getDevice
(uint32_t idx
) const;
const NimBLEAdvertisedDevice* getDevice
(const NimBLEAddress& address
) const;
std::vector<NimBLEAdvertisedDevice*>::
const_iterator
begin
() const;
std::vector<NimBLEAdvertisedDevice*>::
const_iterator end
() const;
private:
friend NimBLEScan;
std::vector<NimBLEAdvertisedDevice*> m_deviceVec;
};
/**
* @brief Perform and manage %BLE scans
.
*
* Scanning is
associated with a %BLE client that is attempting to locate BLE servers
.
*/
cl
ass NimBLEScan {
public:
bool start
(uint32_t duration, bool isContinue = false, bool restart = true
);
bool isScanning
();
void setScanCallbacks
(NimBLEScanCallbacks* pScanCallbacks, bool wantDuplicates = false
);
void setActiveScan
(bool active
);
void setInterval
(uint16_t intervalMs
);
void setWindow
(uint16_t windowMs
);
void setDuplicateFilter
(uint8_t enabled
);
void setLimitedOnly
(bool enabled
);
void setFilterPolicy
(uint8_t filter
);
bool stop
();
void clearResults
();
NimBLEScanResults getResults
();
NimBLEScanResults getResults
(uint32_t duration, bool is_continue = false
);
void setMaxResults
(uint8_t maxResults
);
void er
ase
(const NimBLEAddress& address
);
void er
ase
(const NimBLEAdvertisedDevice* device
);
# if CONFIG_BT_NIMBLE_EXT_ADV
enum Phy { SCAN_1M = 0x01, SCAN_CODED = 0x02, SCAN_ALL = 0x03 };
void setPhy
(Phy phyM
ask
);
void setPeriod
(uint32_t periodMs
);
# endif
private:
friend cl
ass NimBLEDevice;
NimBLEScan
();
~NimBLEScan
();
static int handleGapEvent
(ble_gap_event* event, void* arg
);
void onHostSync
();
NimBLEScanCallbacks* m_pScanCallbacks;
ble_gap_disc_params m_scanParams;
NimBLEScanResults m_scanResults;
NimBLET
askData* m_pT
askData;
uint8_t m_maxResults;
# if CONFIG_BT_NIMBLE_EXT_ADV
uint8_t m_phy{SCAN_ALL};
uint16_t m_period{0};
# endif
};
/**
* @brief A callback handler for callbacks
associated device scanning
.
*/
cl
ass NimBLEScanCallbacks {
public:
virtual ~NimBLEScanCallbacks
() {}
/**
* @brief Called
when a new device is discovered,
before the scan result is received
(if applicable
).
* @param [in] advertisedDevice The device which w
as discovered
.
*/
virtual void onDiscovered
(const NimBLEAdvertisedDevice* advertisedDevice
);
/**
* @brief Called
when a new scan result is complete, including scan response data
(if applicable
).
* @param [in] advertisedDevice The device for which the complete result is available
.
*/
virtual void onResult
(const NimBLEAdvertisedDevice* advertisedDevice
);
/**
* @brief Called
when a scan operation ends
.
* @param [in] scanResults The results of the scan that ended
.
* @param [in] re
ason The re
ason code for why the scan ended
.
*/
virtual void onScanEnd
(const NimBLEScanResults& scanResults, int re
ason
);
};
#endif // CONFIG_BT_ENABLED CONFIG_BT_NIMBLE_ROLE_OBSERVER
#endif // NIMBLE_CPP_SCAN_H_
/*
* Copyright 2020-2025 Ryan Powell <ryan@nable-em
bedded
.io> and
* esp-nimble-cpp, NimBLE-Arduino contributors
.
*
* Licensed under the Apache License, Version 2
.0
(the "License"
);
* you may
not use this file except in compliance with the License
.
* You may obtain a copy of the License at
*
* http://www
.apache
.org/licenses/LICENSE-2
.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "
AS IS" B
ASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
.
* See the License for the specific language governing permissions and
* limitations under the License
.
*/
#ifndef NIMBLE_CPP_ADVERTISED_DEVICE_H_
#define NIMBLE_CPP_ADVERTISED_DEVICE_H_
#include "nimconfig
.h"
#if CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_OBSERVER
# include "NimBLEAddress
.h"
# include "NimBLEScan
.h"
# include "NimBLEUUID
.h"
# if defined
(CONFIG_NIMBLE_CPP_IDF
)
# include "host/ble_hs_adv
.h"
# include "host/ble_gap
.h"
# else
# include "nimble/nimble/host/include/host/ble_hs_adv
.h"
# include "nimble/nimble/host/include/host/ble_gap
.h"
# endif
# include <vector>
cl
ass NimBLEScan;
/**
* @brief A representation of a %BLE advertised device found by a scan
.
*
*
When we perform a %BLE scan, the result will
be a set of devices that are advertising
. This
* cl
ass provides a model of a detected device
.
*/
cl
ass NimBLEAdvertisedDevice {
public:
NimBLEAdvertisedDevice
() = default;
uint8_t getAdvType
() const;
uint8_t getAdvFlags
() const;
uint16_t getAppearance
() const;
uint16_t getAdvInterval
() const;
uint16_t getMinInterval
() const;
uint16_t getMaxInterval
() const;
uint8_t getManufacturerDataCount
() const;
const NimBLEAddress& getAddress
() const;
std::
string getManufacturerData
(uint8_t index = 0
) const;
std::
string getURI
() const;
std::
string getPayloadByType
(uint16_t type, uint8_t index = 0
) const;
std::
string getName
() const;
int8_t getRSSI
() const;
NimBLEScan* getScan
() const;
uint8_t getServiceDataCount
() const;
std::
string getServiceData
(uint8_t index = 0
) const;
std::
string getServiceData
(const NimBLEUUID& uuid
) const;
NimBLEUUID getServiceDataUUID
(uint8_t index = 0
) const;
NimBLEUUID getServiceUUID
(uint8_t index = 0
) const;
uint8_t getServiceUUIDCount
() const;
NimBLEAddress getTargetAddress
(uint8_t index = 0
) const;
uint8_t getTargetAddressCount
() const;
int8_t getTXPower
() const;
uint16_t getAdvLength
() const;
uint8_t getAddressType
() const;
bool isAdvertisingService
(const NimBLEUUID& uuid
) const;
bool haveAppearance
() const;
bool haveManufacturerData
() const;
bool haveName
() const;
bool haveServiceData
() const;
bool haveServiceUUID
() const;
bool haveTXPower
() const;
bool haveConnParams
() const;
bool haveAdvInterval
() const;
bool haveTargetAddress
() const;
bool haveURI
() const;
bool haveType
(uint16_t type
) const;
std::
string to
String() const;
bool isConnectable
() const;
bool isScannable
() const;
bool isLegacyAdvertisement
() const;
# if CONFIG_BT_NIMBLE_EXT_ADV
uint8_t getSetId
() const;
uint8_t getPrimaryPhy
() const;
uint8_t getSecondaryPhy
() const;
uint16_t getPeriodicInterval
() const;
uint8_t getDat
aStatus
() const;
# endif
operator NimBLEAddress
() const;
const std::vector<uint8_t>& getPayload
() const;
const std::vector<uint8_t>::
const_iterator
begin
() const;
const std::vector<uint8_t>::
const_iterator end
() const;
/**
* @brief A template to convert the service data to <type\>
.
* @tparam T The type to convert the data to
.
* @param [in] skipSizeCheck If true it will skip checking if the data size is less than <tt>sizeof
(<type\>
)</tt>
.
* @return The data converted to <type\> or NULL if skipSizeCheck is false and the data is
* less than <tt>sizeof
(<type\>
)</tt>
.
* @details <b>Use:</b> <tt>getManufacturerData<type>
(skipSizeCheck
);</tt>
*/
template <typename T>
T getManufacturerData
(bool skipSizeCheck = false
) const {
std::
string data = getManufacturerData
();
if
(!skipSizeCheck && data
.size
() < sizeof
(T
)) return T
();
const char* pData = data
.data
();
return *
((T*
)pData
);
}
/**
* @brief A template to convert the service data to <tt><type\></tt>
.
* @tparam T The type to convert the data to
.
* @param [in] index The vector index of the service data requested
.
* @param [in] skipSizeCheck If true it will skip checking if the data size is less than <tt>sizeof
(<type\>
)</tt>
.
* @return The data converted to <type\> or NULL if skipSizeCheck is false and the data is
* less than <tt>sizeof
(<type\>
)</tt>
.
* @details <b>Use:</b> <tt>getServiceData<type>
(skipSizeCheck
);</tt>
*/
template <typename T>
T getServiceData
(uint8_t index = 0, bool skipSizeCheck = false
) const {
std::
string data = getServiceData
(index
);
if
(!skipSizeCheck && data
.size
() < sizeof
(T
)) return T
();
const char* pData = data
.data
();
return *
((T*
)pData
);
}
/**
* @brief A template to convert the service data to <tt><type\></tt>
.
* @tparam T The type to convert the data to
.
* @param [in] uuid The uuid of the service data requested
.
* @param [in] skipSizeCheck If true it will skip checking if the data size is less than <tt>sizeof
(<type\>
)</tt>
.
* @return The data converted to <type\> or NULL if skipSizeCheck is false and the data is
* less than <tt>sizeof
(<type\>
)</tt>
.
* @details <b>Use:</b> <tt>getServiceData<type>
(skipSizeCheck
);</tt>
*/
template <typename T>
T getServiceData
(const NimBLEUUID& uuid, bool skipSizeCheck = false
) const {
std::
string data = getServiceData
(uuid
);
if
(!skipSizeCheck && data
.size
() < sizeof
(T
)) return T
();
const char* pData = data
.data
();
return *
((T*
)pData
);
}
private:
friend cl
ass NimBLEScan;
NimBLEAdvertisedDevice
(const ble_gap_event* event, uint8_t eventType
);
void update
(const ble_gap_event* event, uint8_t eventType
);
uint8_t findAdvField
(uint8_t type, uint8_t index = 0, size_t* data_loc = nullptr
) const;
size_t findServiceData
(uint8_t index, uint8_t* bytes
) const;
NimBLEAddress m_address{};
uint8_t m_advType{};
int8_t m_rssi{};
uint8_t m_callbackSent{};
uint16_t m_advLength{};
# if CONFIG_BT_NIMBLE_EXT_ADV
bool m_isLegacyAdv{};
uint8_t m_dat
aStatus{};
uint8_t m_sid{};
uint8_t m_primPhy{};
uint8_t m_secPhy{};
uint16_t m_periodicItvl{};
# endif
std::vector<uint8_t> m_payload;
};
#endif /* CONFIG_BT_ENABLED && CONFIG_BT_NIMBLE_ROLE_OBSERVER */
#endif /* NIMBLE_CPP_ADVERTISED_DEVICE_H_ */
锁定点XXXX
, 本文讨论了当持有某个特定点XXXX时所受到的限制，包括无法修改该内容及无法释放此点。这对于理解特定系统行为及其约束条件非常重要。
扫一扫
2767
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
