13constexpr uint16_t kGapServiceUuid{0x1800};
14constexpr uint16_t kGapDeviceNameUuid{0x2A00};
16constexpr uint16_t kInputsServiceUuid{0xFFA0};
17constexpr uint16_t kInputsCharacteristicUuid{0xFFA1};
19constexpr uint16_t kBatteryServiceUuid{0x180F};
20constexpr uint16_t kBatteryLevelCharacteristicUuid{0x2A19};
22constexpr uint16_t kDeviceInfoServiceUuid{0x180A};
23constexpr uint16_t kModelNumberCharacteristicUuid{0x2A24};
24constexpr uint16_t kSerialNumberCharacteristicUuid{0x2A25};
25constexpr uint16_t kFirmwareRevisionCharacteristicUuid{0x2A26};
26constexpr uint16_t kManufacturerNameCharacteristicUuid{0x2A29};
28constexpr uint16_t kConnectionParamMinInterval{6};
29constexpr uint16_t kConnectionParamMaxInterval{8};
30constexpr uint16_t kConnectionParamLatency{5};
31constexpr uint16_t kConnectionParamSupervisionTimeout{30};
33static_assert(kConnectionParamSupervisionTimeout * 10.0 >
34 (1 + kConnectionParamLatency) * kConnectionParamMaxInterval * 4 * 1.25);
42 if (!NimBLEDevice::isInitialized()) {
43 NimBLEDevice::init(
"Client");
47bool Client::Connect(
const std::string& bluetooth_device_address,
const uint32_t timeout_ms)
noexcept {
49 if (bluetooth_device_address.length() != 17 || bluetooth_device_address[2] !=
':' || bluetooth_device_address[5] !=
':' ||
50 bluetooth_device_address[8] !=
':' || bluetooth_device_address[11] !=
':' || bluetooth_device_address[14] !=
':') {
55 return Connect(NimBLEAddress(bluetooth_device_address, 0),
false, timeout_ms);
59 auto scanner = NimBLEDevice::getScan();
60 scanner->setActiveScan(
true);
61 scanner->setInterval(1000);
62 scanner->setWindow(999);
64 if (!scanner->start(1000)) {
66 scanner->clearResults();
71 while (scanner->isScanning()) {
77 int8_t
rssi = INT8_MIN;
78 NimBLEAddress address;
81 struct ManufacturerSpecificData {
82 uint16_t company_id = 0xFFFF;
83 uint8_t header[8] = {
'C',
'o',
'd',
'e',
'x',
'P',
'a',
'd'};
84 uint8_t version_major = 0;
85 uint8_t version_minor = 0;
86 uint8_t version_patch = 0;
87 uint32_t button_state = 0;
88 uint8_t button_states_duration_seconds = 0;
92 for (
const auto device : scanner->getResults()) {
93 if (device->haveName() && String(device->getName().c_str()).startsWith(
"CodexPad-") && device->haveManufacturerData()) {
95 const auto manufacturer_data = device->getManufacturerData();
96 if (manufacturer_data.length() >=
sizeof(ManufacturerSpecificData)) {
97 const auto data =
reinterpret_cast<const ManufacturerSpecificData*
>(manufacturer_data.c_str());
98 if (data->company_id == 0xFFFF
99 && memcmp(data->header,
"CodexPad", 8) == 0
100 && data->button_state ==
static_cast<uint32_t
>(buttons)
101 && device->getRSSI() >
rssi
102 && (data->version_major < 2 || data->button_states_duration_seconds >= 1)
104 rssi = device->getRSSI();
105 address = device->getAddress();
112 scanner->clearResults();
114 return address.isNull() ? false :
Connect(address, 2000);
118 if (ble_client_ ==
nullptr) {
119 return input_tracker_;
122 if (!ble_client_->isConnected()) {
124 return input_tracker_;
127 input_tracker_.Tick();
130 std::lock_guard<std::mutex> l(mutex_);
131 if (inputs_queue_.empty()) {
135 input_tracker_.Update(inputs_queue_.front());
139 return input_tracker_;
144bool Client::Connect(
const NimBLEAddress& address,
bool async_connect,
const uint32_t timeout_ms) {
146 assert(ble_client_ ==
nullptr);
147 ble_client_ = NimBLEDevice::createClient(address);
148 ble_client_->setConnectTimeout(timeout_ms);
149 ble_client_->setConnectionParams(kConnectionParamMinInterval, kConnectionParamMaxInterval, kConnectionParamLatency,
150 kConnectionParamSupervisionTimeout);
151 ble_client_->setClientCallbacks(
this,
false);
152 auto ret = ble_client_->connect(
true, async_connect,
true);
154 if (!ret || !ble_client_->isConnected()) {
158 remote_device_name_ = ble_client_->getValue(kGapServiceUuid, kGapDeviceNameUuid);
159 remote_model_number_ = ble_client_->getValue(kDeviceInfoServiceUuid, kModelNumberCharacteristicUuid);
161 auto firmware_revision = ble_client_->getValue(kDeviceInfoServiceUuid, kFirmwareRevisionCharacteristicUuid);
162 if (firmware_revision.length() == remote_firmware_version_.size()) {
163 memcpy(remote_firmware_version_.data(), firmware_revision.data(), firmware_revision.length());
168 auto remote_service = ble_client_->getService(kInputsServiceUuid);
169 if (remote_service ==
nullptr) {
173 auto remote_characteristic = remote_service->getCharacteristic(kInputsCharacteristicUuid);
174 if (remote_characteristic ==
nullptr) {
178 if (!remote_characteristic->canNotify()) {
182 if (!remote_characteristic->subscribe(
true, std::bind(&Client::OnNotify,
this, std::placeholders::_1, std::placeholders::_2,
183 std::placeholders::_3, std::placeholders::_4))) {
188 ble_client_->updatePhy(BLE_GAP_LE_PHY_CODED_MASK, BLE_GAP_LE_PHY_CODED_MASK, BLE_GAP_LE_PHY_CODED_S8);
197void Client::OnNotify(
const NimBLERemoteCharacteristic* remote_characteristic,
const uint8_t* data,
const size_t length,
198 const bool is_notify) {
199 if (remote_characteristic !=
nullptr && remote_characteristic->getUUID().equals(kInputsCharacteristicUuid)) {
200 if (length !=
sizeof(gamepad::input::State)) {
201 printf(
"WARNING: length != sizeof(Inputs)\n");
205 std::lock_guard<std::mutex> l(mutex_);
206 if (inputs_queue_.size() > kInputsQueueMax) {
209 inputs_queue_.emplace(gamepad::input::State::FromBytes(data));
213void Client::Reset() {
214 if (ble_client_ !=
nullptr) {
215 ble_client_->cancelConnect();
216 ble_client_->disconnect();
217 NimBLEDevice::deleteClient(ble_client_);
218 ble_client_ =
nullptr;
221 remote_device_name_.clear();
222 remote_model_number_.clear();
223 remote_firmware_version_.fill(0);
224 input_tracker_.Reset();
225 std::lock_guard<std::mutex> l(mutex_);
229int32_t
Client::rssi() const noexcept {
return ble_client_ ==
nullptr ? 0 : ble_client_->getRssi(); }
231void 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
是否连接
bool ScanAndConnect(gamepad::input::Button buttons) noexcept
扫描附近的 CodexPad 设备,并自动连接到一个按键状态与指定掩码匹配的设备。
bool Connect(const std::string &bluetooth_device_address, uint32_t timeout_ms=5000) noexcept
连接
int32_t rssi() const noexcept
获取CodexPad的RSSI