11constexpr uint16_t kGapServiceUuid{0x1800};
12constexpr uint16_t kGapDeviceNameUuid{0x2A00};
14constexpr uint16_t kInputsServiceUuid{0xFFA0};
15constexpr uint16_t kInputsCharacteristicUuid{0xFFA1};
17constexpr uint16_t kBatteryServiceUuid{0x180F};
18constexpr uint16_t kBatteryLevelCharacteristicUuid{0x2A19};
20constexpr uint16_t kDeviceInfoServiceUuid{0x180A};
21constexpr uint16_t kModelNumberCharacteristicUuid{0x2A24};
22constexpr uint16_t kSerialNumberCharacteristicUuid{0x2A25};
23constexpr uint16_t kFirmwareRevisionCharacteristicUuid{0x2A26};
24constexpr uint16_t kManufacturerNameCharacteristicUuid{0x2A29};
26constexpr uint16_t kConnectionParamMinInterval{6};
27constexpr uint16_t kConnectionParamMaxInterval{8};
28constexpr uint16_t kConnectionParamLatency{5};
29constexpr uint16_t kConnectionParamSupervisionTimeout{30};
31static_assert(kConnectionParamSupervisionTimeout * 10.0 >
32 (1 + kConnectionParamLatency) * kConnectionParamMaxInterval * 4 * 1.25);
34constexpr uint64_t kUpdateTxPowerIntervalMs{1000};
37constexpr int32_t kRssiQuantizerMin = -90;
38constexpr int32_t kRssiQuantizerMax = -40;
39constexpr uint32_t kRssiQuantizerLevels = 4;
40constexpr int32_t kRssiQuantizerDivisor = 3;
42constexpr uint32_t kRssiQuantizerMaxLevel = kRssiQuantizerLevels - 1;
43constexpr int32_t kTxPowerLevelMultiplier = 3;
47 : rssi_quantizer_(kRssiQuantizerMin, kRssiQuantizerMax, kRssiQuantizerLevels, kRssiQuantizerDivisor) {}
52 if (!NimBLEDevice::isInitialized()) {
53 NimBLEDevice::init(
"CodexPadClient");
57bool Client::Connect(
const std::string& address,
const uint32_t timeout_ms)
noexcept {
59 if (address.length() != 17 || address[2] !=
':' || address[5] !=
':' || address[8] !=
':' || address[11] !=
':' ||
65 return Connect(NimBLEAddress(address, 0),
false, timeout_ms);
69 auto scanner = NimBLEDevice::getScan();
70 scanner->setActiveScan(
true);
71 scanner->setInterval(1000);
72 scanner->setWindow(999);
74 if (!scanner->start(1000)) {
76 scanner->clearResults();
81 while (scanner->isScanning()) {
87 int8_t
rssi = INT8_MIN;
88 NimBLEAddress address;
91 struct ManufacturerSpecificData {
92 uint16_t company_id = 0xFFFF;
93 uint8_t header[8] = {
'C',
'o',
'd',
'e',
'x',
'P',
'a',
'd'};
94 uint8_t version_major = 0;
95 uint8_t version_minor = 0;
96 uint8_t version_patch = 0;
97 uint32_t button_state = 0;
98 uint8_t button_states_duration_seconds = 0;
102 for (
const auto device : scanner->getResults()) {
103 if (device->haveName() && String(device->getName().c_str()).startsWith(
"CodexPad-") && device->haveManufacturerData()) {
105 const auto manufacturer_data = device->getManufacturerData();
106 if (manufacturer_data.length() >=
sizeof(ManufacturerSpecificData)) {
107 const auto data =
reinterpret_cast<const ManufacturerSpecificData*
>(manufacturer_data.c_str());
108 if (data->company_id == 0xFFFF
109 && memcmp(data->header,
"CodexPad", 8) == 0
110 && data->button_state ==
static_cast<uint32_t
>(buttons)
111 && device->getRSSI() >
rssi
112 && (data->version_major < 2 || data->button_states_duration_seconds >= 1)
114 rssi = device->getRSSI();
115 address = device->getAddress();
122 scanner->clearResults();
124 return address.isNull() ? false :
Connect(address, 2000);
128 if (ble_client_ ==
nullptr) {
129 return input_tracker_;
132 if (!ble_client_->isConnected()) {
134 return input_tracker_;
137 input_tracker_.Tick();
140 std::lock_guard<std::mutex> l(mutex_);
141 if (inputs_queue_.empty()) {
145 input_tracker_.Update(inputs_queue_.front());
151#if !defined(ESP_ARDUINO_VERSION) || ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 1, 0)
155 return input_tracker_;
160bool Client::Connect(
const NimBLEAddress& address,
bool async_connect,
const uint32_t timeout_ms) {
162 assert(ble_client_ ==
nullptr);
163 ble_client_ = NimBLEDevice::createClient(address);
164 ble_client_->setConnectTimeout(timeout_ms);
165 ble_client_->setConnectionParams(kConnectionParamMinInterval, kConnectionParamMaxInterval, kConnectionParamLatency,
166 kConnectionParamSupervisionTimeout);
167 ble_client_->setClientCallbacks(
this,
false);
168 auto ret = ble_client_->connect(
true, async_connect,
true);
170 if (!ret || !ble_client_->isConnected()) {
174 remote_device_name_ = ble_client_->getValue(kGapServiceUuid, kGapDeviceNameUuid);
175 remote_model_number_ = ble_client_->getValue(kDeviceInfoServiceUuid, kModelNumberCharacteristicUuid);
177 auto firmware_revision = ble_client_->getValue(kDeviceInfoServiceUuid, kFirmwareRevisionCharacteristicUuid);
178 if (firmware_revision.length() == remote_firmware_version_.size()) {
179 memcpy(remote_firmware_version_.data(), firmware_revision.data(), firmware_revision.length());
184 auto remote_service = ble_client_->getService(kInputsServiceUuid);
185 if (remote_service ==
nullptr) {
189 auto remote_characteristic = remote_service->getCharacteristic(kInputsCharacteristicUuid);
190 if (remote_characteristic ==
nullptr) {
194 if (!remote_characteristic->canNotify()) {
198 if (!remote_characteristic->subscribe(
true, std::bind(&Client::OnNotify,
this, std::placeholders::_1, std::placeholders::_2,
199 std::placeholders::_3, std::placeholders::_4))) {
204 ble_client_->updatePhy(BLE_GAP_LE_PHY_CODED_MASK, BLE_GAP_LE_PHY_CODED_MASK, BLE_GAP_LE_PHY_CODED_S8);
206 if (local_tx_power_ != INT32_MIN) {
207 NimBLEDevice::setPower(local_tx_power_, NimBLETxPowerType::All);
217void Client::OnNotify(
const NimBLERemoteCharacteristic* remote_characteristic,
const uint8_t* data,
const size_t length,
218 const bool is_notify) {
219 if (remote_characteristic !=
nullptr && remote_characteristic->getUUID().equals(kInputsCharacteristicUuid)) {
220 if (length !=
sizeof(gamepad::input::State)) {
221 printf(
"WARNING: length != sizeof(Inputs)\n");
225 std::lock_guard<std::mutex> l(mutex_);
226 if (inputs_queue_.size() > kInputsQueueMax) {
229 inputs_queue_.emplace(gamepad::input::State::FromBytes(data));
233void Client::Reset() {
234 if (ble_client_ !=
nullptr) {
235 ble_client_->cancelConnect();
236 ble_client_->disconnect();
237 NimBLEDevice::deleteClient(ble_client_);
238 ble_client_ =
nullptr;
241 remote_device_name_.clear();
242 remote_model_number_.clear();
243 remote_firmware_version_.fill(0);
244 input_tracker_.Reset();
245 std::lock_guard<std::mutex> l(mutex_);
247 rssi_quantizer_.Reset();
248 last_update_tx_power_ms_ = 0;
251void Client::UpdateTxPower() {
252 if (!dynamic_tx_power_enabled_) {
256 if (ble_client_ ==
nullptr) {
260 if (!ble_client_->isConnected()) {
264 if (last_update_tx_power_ms_ != 0 && last_update_tx_power_ms_ + kUpdateTxPowerIntervalMs > millis()) {
268 last_update_tx_power_ms_ = millis();
270 const int32_t
rssi = ble_client_->getRssi();
271 const uint32_t tx_power_level = kRssiQuantizerMaxLevel - rssi_quantizer_.Update(
rssi);
272 NimBLEDevice::setPower(tx_power_level * kTxPowerLevelMultiplier, NimBLETxPowerType::All);
275int32_t
Client::rssi() const noexcept {
return ble_client_ ==
nullptr ? 0 : ble_client_->getRssi(); }
277void Client::onPhyUpdate(NimBLEClient*, [[maybe_unused]] uint8_t tx_phy, [[maybe_unused]] uint8_t rx_phy) {
const gamepad::input::Tracker & Update() noexcept
更新,需要在Loop中不断调用
bool is_connected() const noexcept
是否连接
int32_t rssi() const noexcept
获取已连接 CodexPad 的 RSSI(接收信号强度指示)。
bool Connect(const std::string &address, uint32_t timeout_ms=5000) noexcept
连接