[{
"resource": "/F:/文档/PlatformIO/Projects/spi1032/src/main
.cpp",
"owner": "C/C++: IntelliSense",
"code": "1455",
"severity": 8,
"message": "使用“override”声明的成员函数不能重写基类成员",
"source": "C/C++",
"startLineNumber": 58,
"startColumn": 10,
"endLineNumber": 58,
"endColumn": 19,
"origin": "extHost1"
},{
"resource": "/F:/文档/PlatformIO/Projects/spi1032/src/main
.cpp",
"owner": "C/C++: IntelliSense",
"code": "1455",
"severity": 8,
"message": "使用“override”声明的成员函数不能重写基类成员",
"source": "C/C++",
"startLineNumber": 63,
"startColumn": 10,
"endLineNumber": 63,
"endColumn": 22,
"origin": "extHost1"
},{
"resource": "/F:/文档/PlatformIO/Projects/spi1032/src/main
.cpp",
"owner": "C/C++: IntelliSense",
"code": "1455",
"severity": 8,
"message": "使用“override”声明的成员函数不能重写基类成员",
"source": "C/C++",
"startLineNumber": 71,
"startColumn": 10,
"endLineNumber": 71,
"endColumn": 17,
"origin": "extHost1"
},{
"resource": "/F:/文档/PlatformIO/Projects/spi1032/src/main
.cpp",
"owner": "C/C++: IntelliSense",
"code": "135",
"severity": 8,
"message": "类 \"NimBLEAdvertising\" 没有成员 \"setScanResponse\"",
"source": "C/C++",
"startLineNumber": 347,
"startColumn": 19,
"endLineNumber": 347,
"endColumn": 34,
"origin": "extHost1"
}]
/*
* Copyright 2020-2025 Ryan Powell <ryan@
nable-embedded
.io> and
* esp-nimble-cpp, NimBLE-Arduino contribu
tors
.
*
* 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, s
oftware
* distributed under
the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS
OF ANY KIND, ei
ther express or implied
.
* See
the License for
the specific language governing permissions and
* limitations under
the License
.
*/
#ifndef NIMBLE_CPP_CHARACTERISTIC_H_
#define NIMBLE_CPP_CHARACTERISTIC_H_
#include "nimconfig
.h"
#if CONFIG_BT_E
NABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
class NimBLECharacteristicCallbacks;
class NimBLEService;
class NimBLECharacteristic;
class NimBLEDescrip
tor;
class NimBLE2904;
# include "NimBLELocal
ValueAttribute
.h"
# include <string>
# include <vec
tor>
/**
* @brief
The model
of a BLE Characteristic
.
*
* A BLE Characteristic is an identified
value container that manages a
value. It is exposed by a BLE service and
* can be read and written
to by a BLE client
.
*/
class NimBLECharacteristic : public NimBLELocal
ValueAttribute {
public:
NimBLECharacteristic(const char* uuid,
uint16_t properties = NIMBLE_
PROPERTY::READ | NIMBLE_
PROPERTY::WRITE,
uint16_t maxLen = BLE_ATT_ATTR_MAX_LEN,
NimBLEService* pService = nullptr);
NimBLECharacteristic(const NimBLEUUID& uuid,
uint16_t properties = NIMBLE_
PROPERTY::READ | NIMBLE_
PROPERTY::WRITE,
uint16_t maxLen = BLE_ATT_ATTR_MAX_LEN,
NimBLEService* pService = nullptr);
~NimBLECharacteristic();
std::string
toString() const;
void addDescrip
tor(NimBLEDescrip
tor* pDescrip
tor);
void removeDescrip
tor(NimBLEDescrip
tor* pDescrip
tor, bool deleteDsc = false);
uint16_t
getProperties() const;
void setCallbacks(NimBLECharacteristicCallbacks* pCallbacks);
bool indicate(uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const;
bool indicate(const uint8_t*
value, size_t length, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const;
bool notify(uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const;
bool notify(const uint8_t*
value, size_t length, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const;
NimBLEDescrip
tor* createDescrip
tor(const char* uuid,
uint32_t properties = NIMBLE_
PROPERTY::READ | NIMBLE_
PROPERTY::WRITE,
uint16_t maxLen = BLE_ATT_ATTR_MAX_LEN);
NimBLEDescrip
tor* createDescrip
tor(const NimBLEUUID& uuid,
uint32_t properties = NIMBLE_
PROPERTY::READ | NIMBLE_
PROPERTY::WRITE,
uint16_t maxLen = BLE_ATT_ATTR_MAX_LEN);
NimBLE2904* create2904();
NimBLEDescrip
tor*
getDescrip
torByUUID(const char* uuid) const;
NimBLEDescrip
tor*
getDescrip
torByUUID(const NimBLEUUID& uuid) const;
NimBLEDescrip
tor*
getDescrip
torByHandle(uint16_t handle) const;
NimBLEService*
getService() const;
NimBLECharacteristicCallbacks*
getCallbacks() const;
/*********************** Template Functions ************************/
# if __cplusplus < 201703L
/**
* @brief Template
to send a notification with a
value from a struct or array
.
* @param [in] v
The value to send
.
* @param [in] connHandle Optional, a connection handle
to send
the notification
to.
* @details <type\> size must be evaluatable by `size
of()`
.
*/
template <typename T>
# ifdef _DOXYGEN_
bool
# else
typename std::e
nable_if<!std::is_pointer<T>::
value && !std::is_array<T>::
value && !Has_c_str_length<T>::
value &&
!Has_data_size<T>::
value,
bool>::type
# endif
notify(const T& v, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
return notify(reinterpret_cast<const uint8_t*>(&v), size
of(T), connHandle);
}
/**
* @brief Template
to send a notification with a
value from a class that has a c_str() and length() method
.
* @param [in] s
The value to send
.
* @param [in] connHandle Optional, a connection handle
to send
the notification
to.
*/
template <typename T>
# ifdef _DOXYGEN_
bool
# else
typename std::e
nable_if<Has_c_str_length<T>::
value && !Has_data_size<T>::
value, bool>::type
# endif
notify(const T& s, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
return notify(reinterpret_cast<const uint8_t*>(s
.c_str()), s
.length(), connHandle);
}
/**
* @brief Template
to send a notification with a
value from a class that has a data() and size() method
.
* @param [in] v
The value to send
.
* @param [in] connHandle Optional, a connection handle
to send
the notification
to.
*/
template <typename T>
# ifdef _DOXYGEN_
bool
# else
typename std::e
nable_if<Has_data_size<T>::
value, bool>::type
# endif
notify(const T& v, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
return notify(reinterpret_cast<const uint8_t*>(v
.data()), v
.size(), connHandle);
}
/**
* @brief Template
to send an indication with a
value from a struct or array
.
* @param [in] v
The value to send
.
* @param [in] connHandle Optional, a connection handle
to send
the notification
to.
* @details <type\> size must be evaluatable by `size
of()`
.
*/
template <typename T>
# ifdef _DOXYGEN_
bool
# else
typename std::e
nable_if<!std::is_pointer<T>::
value && !std::is_array<T>::
value && !Has_c_str_length<T>::
value &&
!Has_data_size<T>::
value,
bool>::type
# endif
indicate(const T& v, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
return indicate(reinterpret_cast<const uint8_t*>(&v), size
of(T), connHandle);
}
/**
* @brief Template
to send a indication with a
value from a class that has a c_str() and length() method
.
* @param [in] s
The value to send
.
* @param [in] connHandle Optional, a connection handle
to send
the notification
to.
*/
template <typename T>
# ifdef _DOXYGEN_
bool
# else
typename std::e
nable_if<Has_c_str_length<T>::
value && !Has_data_size<T>::
value, bool>::type
# endif
indicate(const T& s, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
return indicate(reinterpret_cast<const uint8_t*>(s
.c_str()), s
.length(), connHandle);
}
/**
* @brief Template
to send a indication with a
value from a class that has a data() and size() method
.
* @param [in] v
The value to send
.
* @param [in] connHandle Optional, a connection handle
to send
the notification
to.
*/
template <typename T>
# ifdef _DOXYGEN_
bool
# else
typename std::e
nable_if<Has_data_size<T>::
value, bool>::type
# endif
indicate(const T& v, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
return indicate(reinterpret_cast<const uint8_t*>(v
.data()), v
.size(), connHandle);
}
# else
/**
* @brief Template
to send a notification for classes which may have
* data()/size() or c_str()/length() methods
. Falls back
to sending
*
the data by casting
the first element
of the array
to a uint8_t
* pointer and
getting
the length
of the array using size
of.
* @tparam T
The a reference
to a class containing
the data
to send
.
* @param[in]
value The <type\>
value to set
.
* @param[in] connHandle
The connection handle
to send
the notification
to.
* @note
This function is only available if
the type T is not a pointer
.
*/
template <typename T>
typename std::e
nable_if<!std::is_pointer<T>::
value && !std::is_array<T>::
value, bool>::type notify(
const T&
value, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
if constexpr (Has_data_size<T>::
value) {
return notify(reinterpret_cast<const uint8_t*>(
value.data()),
value.size(), connHandle);
} else if constexpr (Has_c_str_length<T>::
value) {
return notify(reinterpret_cast<const uint8_t*>(
value.c_str()),
value.length(), connHandle);
} else {
return notify(reinterpret_cast<const uint8_t*>(&
value), size
of(
value), connHandle);
}
}
/**
* @brief Template
to send an indication for classes which may have
* data()/size() or c_str()/length() methods
. Falls back
to sending
*
the data by casting
the first element
of the array
to a uint8_t
* pointer and
getting
the length
of the array using size
of.
* @tparam T
The a reference
to a class containing
the data
to send
.
* @param[in]
value The <type\>
value to set
.
* @param[in] connHandle
The connection handle
to send
the indication
to.
* @note
This function is only available if
the type T is not a pointer
.
*/
template <typename T>
typename std::e
nable_if<!std::is_pointer<T>::
value && !std::is_array<T>::
value, bool>::type indicate(
const T&
value, uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const {
if constexpr (Has_data_size<T>::
value) {
return indicate(reinterpret_cast<const uint8_t*>(
value.data()),
value.size(), connHandle);
} else if constexpr (Has_c_str_length<T>::
value) {
return indicate(reinterpret_cast<const uint8_t*>(
value.c_str()),
value.length(), connHandle);
} else {
return indicate(reinterpret_cast<const uint8_t*>(&
value), size
of(
value), connHandle);
}
}
# endif
private:
friend class NimBLEServer;
friend class NimBLEService;
void setService(NimBLEService* pService);
void readEvent(NimBLEConnInfo& connInfo) override;
void writeEvent(const uint8_t* val, uint16_t len, NimBLEConnInfo& connInfo) override;
bool send
Value(const uint8_t*
value,
size_t length,
bool is_notification = true,
uint16_t connHandle = BLE_HS_CONN_HANDLE_NONE) const;
NimBLECharacteristicCallbacks* m_pCallbacks{nullptr};
NimBLEService* m_pService{nullptr};
std::vec
tor<NimBLEDescrip
tor*> m_vDescrip
tors{};
}; // NimBLECharacteristic
/**
* @brief Callbacks that can be associated with a %BLE characteristic
to inform
of events
.
*
* When a server application creates a %BLE characteristic, we may wish
to be informed when
there is ei
ther
* a read or write request
to the characteristic's
value. An application can register a
* sub-classed instance
of this class and will be notified when such an event happens
.
*/
class NimBLECharacteristicCallbacks {
public:
virtual ~NimBLECharacteristicCallbacks() {}
virtual void onRead(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo);
virtual void onWrite(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo);
virtual void onStatus(NimBLECharacteristic* pCharacteristic, int code);
virtual void onSubscribe(NimBLECharacteristic* pCharacteristic, NimBLEConnInfo& connInfo, uint16_t sub
Value);
};
#endif // CONFIG_BT_E
NABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
#endif // NIMBLE_CPP_CHARACTERISTIC_H_
/*
* Copyright 2020-2025 Ryan Powell <ryan@
nable-embedded
.io> and
* esp-nimble-cpp, NimBLE-Arduino contribu
tors
.
*
* 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, s
oftware
* distributed under
the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS
OF ANY KIND, ei
ther express or implied
.
* See
the License for
the specific language governing permissions and
* limitations under
the License
.
*/
#ifndef NIMBLE_CPP_ADVERTISING_H_
#define NIMBLE_CPP_ADVERTISING_H_
#include "nimconfig
.h"
#if (CONFIG_BT_E
NABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER && !CONFIG_BT_NIMBLE_EXT_ADV) || defined(_DOXYGEN_)
# 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 "NimBLEUUID
.h"
# include "NimBLEAddress
.h"
# include "NimBLEAdvertisementData
.h"
# include <functional>
# include <string>
# include <vec
tor>
class NimBLEAdvertising;
typedef std::function<void(NimBLEAdvertising*)> advCompleteCB_t;
/**
* @brief Perform and manage BLE advertising
.
*
* A BLE server will want
to perform advertising in order
to make itself known
to BLE clients
.
*/
class NimBLEAdvertising {
public:
NimBLEAdvertising();
bool start(uint32_t duration = 0, const NimBLEAddress* dirAddr = nullptr);
void setAdvertisingCompleteCallback(advCompleteCB_t callback);
bool s
top();
bool setConnectableMode(uint8_t mode);
bool setDiscoverableMode(uint8_t mode);
bool reset();
bool isAdvertising();
void setScanFilter(bool scanRequestWhitelis
tOnly, bool connectWhitelis
tOnly);
void e
nableScanResponse(bool e
nable);
void setAdvertisingInterval(uint16_t interval);
void setMaxInterval(uint16_t maxInterval);
void setMinInterval(uint16_t minInterval);
bool setAdvertisementData(const NimBLEAdvertisementData& advertisementData);
bool setScanResponseData(const NimBLEAdvertisementData& advertisementData);
const NimBLEAdvertisementData&
getAdvertisementData();
const NimBLEAdvertisementData&
getScanData();
void clearData();
bool refreshAdvertisingData();
bool addServiceUUID(const NimBLEUUID& serviceUUID);
bool addServiceUUID(const char* serviceUUID);
bool removeServiceUUID(const NimBLEUUID& serviceUUID);
bool removeServiceUUID(const char* serviceUUID);
bool removeServices();
bool setAppearance(uint16_t appearance);
bool setPreferredParams(uint16_t minInterval, uint16_t maxInterval);
bool addTxPower();
bool setName(const std::string& name);
bool setManufacturerData(const uint8_t* data, size_t length);
bool setManufacturerData(const std::string& data);
bool setManufacturerData(const std::vec
tor<uint8_t>& data);
bool setURI(const std::string& uri);
bool setServiceData(const NimBLEUUID& uuid, const uint8_t* data, size_t length);
bool setServiceData(const NimBLEUUID& uuid, const std::string& data);
bool setServiceData(const NimBLEUUID& uuid, const std::vec
tor<uint8_t>& data);
private:
friend class NimBLEDevice;
friend class NimBLEServer;
void onHostSync();
static int handleGapEvent(ble_gap_event* event, void* arg);
NimBLEAdvertisementData m_advData;
NimBLEAdvertisementData m_scanData;
ble_gap_adv_params m_advParams;
advCompleteCB_t m_advCompCb;
uint8_t m_slaveItvl[4];
uint32_t m_duration;
bool m_scanResp : 1;
bool m_advDataSet : 1;
};
#endif // (CONFIG_BT_E
NABLED && CONFIG_BT_NIMBLE_ROLE_BROADCASTER && !CONFIG_BT_NIMBLE_EXT_ADV) || defined(_DOXYGEN_)
#endif // NIMBLE_CPP_ADVERTISING_H_
/*
* Copyright 2020-2025 Ryan Powell <ryan@
nable-embedded
.io> and
* esp-nimble-cpp, NimBLE-Arduino contribu
tors
.
*
* 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, s
oftware
* distributed under
the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS
OF ANY KIND, ei
ther express or implied
.
* See
the License for
the specific language governing permissions and
* limitations under
the License
.
*/
#ifndef NIMBLE_CPP_SERVER_H_
#define NIMBLE_CPP_SERVER_H_
#include "nimconfig
.h"
#if CONFIG_BT_E
NABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
# 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 <vec
tor>
# include <array>
# define NIMBLE_ATT_REMOVE_HIDE 1
# define NIMBLE_ATT_REMOVE_DELETE 2
class NimBLEService;
class NimBLEServerCallbacks;
class NimBLEUUID;
class NimBLEConnInfo;
class NimBLEAddress;
class NimBLEService;
class NimBLECharacteristic;
# if CONFIG_BT_NIMBLE_ROLE_BROADCASTER
# if CONFIG_BT_NIMBLE_EXT_ADV
class NimBLEExtAdvertising;
# else
class NimBLEAdvertising;
# endif
# endif
# if CONFIG_BT_NIMBLE_ROLE_CENTRAL
class NimBLEClient;
# endif
/**
* @brief
The model
of a BLE server
.
*/
class NimBLEServer {
public:
void start();
uint8_t
getConnectedCount() const;
bool disconnect(uint16_t connHandle, uint8_t reason = BLE_ERR_REM_USER_CONN_TERM) const;
bool disconnect(const NimBLEConnInfo& connInfo, uint8_t reason = BLE_ERR_REM_USER_CONN_TERM) const;
void setCallbacks(NimBLEServerCallbacks* pCallbacks, bool deleteCallbacks = true);
void updateConnParams(uint16_t connHandle, uint16_t minInterval, uint16_t maxInterval, uint16_t latency, uint16_t timeout) const;
NimBLEService* createService(const char* uuid);
NimBLEService* createService(const NimBLEUUID& uuid);
NimBLEService*
getServiceByUUID(const char* uuid, uint16_t instanceId = 0) const;
NimBLEService*
getServiceByUUID(const NimBLEUUID& uuid, uint16_t instanceId = 0) const;
NimBLEService*
getServiceByHandle(uint16_t handle) const;
void removeService(NimBLEService* service, bool deleteSvc = false);
void addService(NimBLEService* service);
uint16_t
getPeerMTU(uint16_t connHandle) const;
std::vec
tor<uint16_t>
getPeerDevices() const;
NimBLEConnInfo
getPeerInfo(uint8_t index) const;
NimBLEConnInfo
getPeerInfo(const NimBLEAddress& address) const;
NimBLEConnInfo
getPeerInfoByHandle(uint16_t connHandle) const;
void advertiseOnDisconnect(bool e
nable);
void setDataLen(uint16_t connHandle, uint16_t tx_octets) const;
bool updatePhy(uint16_t connHandle, uint8_t txPhysMask, uint8_t rxPhysMask, uint16_t phyOptions);
bool
getPhy(uint16_t connHandle, uint8_t* txPhy, uint8_t* rxPhy);
# if CONFIG_BT_NIMBLE_ROLE_CENTRAL
NimBLEClient*
getClient(uint16_t connHandle);
NimBLEClient*
getClient(const NimBLEConnInfo& connInfo);
void deleteClient();
# endif
# if CONFIG_BT_NIMBLE_ROLE_BROADCASTER
# if CONFIG_BT_NIMBLE_EXT_ADV
NimBLEExtAdvertising*
getAdvertising() const;
bool startAdvertising(uint8_t instanceId, int duration = 0, int maxEvents = 0) const;
bool s
topAdvertising(uint8_t instanceId) const;
# endif
# if !CONFIG_BT_NIMBLE_EXT_ADV || defined(_DOXYGEN_)
NimBLEAdvertising*
getAdvertising() const;
bool startAdvertising(uint32_t duration = 0) const;
bool s
topAdvertising() const;
# endif
# endif
private:
friend class NimBLEDevice;
friend class NimBLEService;
friend class NimBLECharacteristic;
# if CONFIG_BT_NIMBLE_ROLE_BROADCASTER
# if CONFIG_BT_NIMBLE_EXT_ADV
friend class NimBLEExtAdvertising;
# else
friend class NimBLEAdvertising;
# endif
# endif
NimBLEServer();
~NimBLEServer();
bool m_gattsStarted : 1;
bool m_svcChanged : 1;
bool m_deleteCallbacks : 1;
# if !CONFIG_BT_NIMBLE_EXT_ADV
bool m_advertiseOnDisconnect : 1;
# endif
NimBLEServerCallbacks* m_pServerCallbacks;
std::vec
tor<NimBLEService*> m_svcVec;
std::array<uint16_t, CONFIG_BT_NIMBLE_MAX_CONNECTIONS> m_connectedPeers;
# if CONFIG_BT_NIMBLE_ROLE_CENTRAL
NimBLEClient* m_pClient{nullptr};
# endif
static int handleGapEvent(struct ble_gap_event* event, void* arg);
static int handleGattEvent(uint16_t connHandle, uint16_t attrHandle, ble_gatt_access_ctxt* ctxt, void* arg);
void serviceChanged();
void resetGATT();
}; // NimBLEServer
/**
* @brief Callbacks associated with
the operation
of a BLE server
.
*/
class NimBLEServerCallbacks {
public:
virtual ~NimBLEServerCallbacks() {};
/**
* @brief Handle a client connection
.
*
This is called when a client connects
.
* @param [in] pServer A pointer
to the BLE server that received
the client connection
.
* @param [in] connInfo A reference
to a NimBLEConnInfo instance with information
.
* about
the peer connection parameters
.
*/
virtual void onConnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo);
/**
* @brief Handle a client disconnection
.
*
This is called when a client disconnects
.
* @param [in] pServer A pointer
to the BLE server that received
the client disconnection
.
* @param [in] connInfo A reference
to a NimBLEConnInfo instance with information
* about
the peer connection parameters
.
* @param [in] reason
The reason code for
the disconnection
.
*/
virtual void onDisconnect(NimBLEServer* pServer, NimBLEConnInfo& connInfo, int reason);
/**
* @brief Called when
the connection MTU changes
.
* @param [in] MTU
The new MTU
value.
* @param [in] connInfo A reference
to a NimBLEConnInfo instance with information
* about
the peer connection parameters
.
*/
virtual void onMTUChange(uint16_t MTU, NimBLEConnInfo& connInfo);
/**
* @brief Called when a client requests a passkey for pairing (display)
.
* @return
The passkey
to be sent
to the client
.
*/
virtual uint32_t onPassKeyDisplay();
/**
* @brief Called when using numeric comparision for pairing
.
* @param [in] connInfo A reference
to a NimBLEConnInfo instance with information
* Should be passed back
to NimBLEDevice::injectConfirmPasskey
* @param [in] pin
The pin
to compare with
the client
.
*/
virtual void onConfirmPassKey(NimBLEConnInfo& connInfo, uint32_t pin);
/**
* @brief Called when
the pairing procedure is complete
.
* @param [in] connInfo A reference
to a NimBLEConnInfo instance with information
* about
the peer connection parameters
.
*/
virtual void onAu
thenticationComplete(NimBLEConnInfo& connInfo);
/**
* @brief Called when
the peer identity address is resolved
.
* @param [in] connInfo A reference
to a NimBLEConnInfo instance with information
*/
virtual void onIdentity(NimBLEConnInfo& connInfo);
/**
* @brief Called when connection parameters are updated following a request
to
* update via NimBLEServer::updateConnParams
* @param [in] connInfo A reference
to a NimBLEConnInfo instance containing
the
* updated connection parameters
.
*/
virtual void onConnParamsUpdate(NimBLEConnInfo& connInfo);
/**
* @brief Called when
the PHY update procedure is complete
.
* @param [in] connInfo A reference
to a NimBLEConnInfo instance with information
* about
the peer connection parameters
.
* @param [in] txPhy
The transmit PHY
.
* @param [in] rxPhy
The receive PHY
.
* Possible
values:
* * BLE_GAP_LE_PHY_1M
* * BLE_GAP_LE_PHY_2M
* * BLE_GAP_LE_PHY_CODED
*/
virtual void onPhyUpdate(NimBLEConnInfo& connInfo, uint8_t txPhy, uint8_t rxPhy);
}; // NimBLEServerCallbacks
#endif // CONFIG_BT_E
NABLED && CONFIG_BT_NIMBLE_ROLE_PERIPHERAL
#endif // NIMBLE_CPP_SERVER_H_
本文解决在IE9浏览器中遇到的JavaScript错误问题，通过在HTML头部添加特定的X-UA-Compatible元标签，以IE8模式运行，解决了无法获取属性值的问题。
扫一扫
1157
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
