StickC与BLE HID的NimBLE通讯实验

vany5921

安装NimBLE
以前尝试过使用ESP-IDF4.0中包含的NimBLE,但是不能很好地工作，因此请下载此Github库。GitHub - h2zero/NimBLE-Arduino: A fork of the NimBLE library structured for compilation with Ardruino, designed for use with ESP32.按页面上的“Code”按钮，然后选择“Download ZIP”以开始下载

sketch>ZIP>包含库>安装ZIP格式库并指定下载的ZIP即可使用，找到NimBLE_Client示例进行修改，与HID连接并使用“Report Charcteristic”定义UUID

1. // UUID HID
   
2. static NimBLEUUID serviceUUID("1812");
   
3. // UUID Report Charcteristic
   
4. static NimBLEUUID charUUID("2a4d");
   

复制代码

修改NimBLEAdvertisedDeviceCallbacks以使用HID UUID

1. class AdvertisedDeviceCallbacks: public NimBLEAdvertisedDeviceCallbacks {
   
2. 
   
3.   void onResult(NimBLEAdvertisedDevice *advertisedDevice) {
   
4.     Serial.print("Advertised Device found: ");
   
5. // toString()有问题吗？
   
6. //        Serial.println(advertisedDevice->toString().c_str());
   
7.     Serial.printf("name:%s,address:%s", advertisedDevice->getName().c_str(), advertisedDevice->getAddress().toString().c_str());
   
8.     Serial.printf("UUID:%s\n", advertisedDevice->haveServiceUUID() ? advertisedDevice->getServiceUUID().toString().c_str() : "none");
   
9. 
   
10.     // HID UUID检查是否正确并停止扫描
    
11.     if (advertisedDevice->isAdvertisingService(serviceUUID)) {
    
12.       Serial.println("Found Our Service");
    
13.       /** stop scan before connecting */
    
14.       NimBLEDevice::getScan()->stop();
    
15.       /** Save the device reference in a global for the client to use*/
    
16.       advDevice = advertisedDevice;
    
17.       /** Ready to connect now */
    
18.       doConnect = true;
    
19.     }
    
20.   }
    
21.   ;
    
22. };
    

复制代码

在connectToServer（）中，使用HID UUID重写UUID“ DEAD”，“ BEEF”，“ BAAD”，“ F00D”等。此外，在示例中，假设一个UUID中存在多个特征。在下图中，HID UUID（1812）下有多个报告特征（2a4d)（似乎只有一个）除非您不小心绘制了正确的特征，否则它将永远不会移动。顺便说一句，正确的答案是该图像中带有2个描述符。


因此，对其进行修改以获取多个部分以获取特征在库中，我发现了std :: vector * NimBLERemoteService :: getCharacteristics（bool refresh），所以修改196行

1.   NimBLERemoteService *pSvc = nullptr;
   
2. // 使用向量处理多个
   
3. //  NimBLERemoteCharacteristic *pChr = nullptr;
   
4.   std::vector<NimBLERemoteCharacteristic*> *pChrs = nullptr;
   
5. 
   
6.   NimBLERemoteDescriptor *pDsc = nullptr;
   
7. 
   
8.   // 获取HID服务
   
9.   pSvc = pClient->getService(serviceUUID);
   
10.   if (pSvc) { /** make sure it's not null */
    
11.     // 获取多个Characteristics（参数为真）
    
12.     pChrs = pSvc->getCharacteristics(true);
    
13.   }
    
14. 
    
15.   if (pChrs) { /** make sure it's not null */
    
16.     //将具有“Notify”属性的属性从多个“Report Characterisitics”注册到“Callback”。
    
17.     for (int i = 0; i < pChrs->size(); i++) {
    
18. 
    
19.       if (pChrs->at(i)->canNotify()) {
    
20.         if (!pChrs->at(i)->registerForNotify(notifyCB)) {
    
21.           /** Disconnect if subscribe failed */
    
22.           pClient->disconnect();
    
23.           return false;
    
24.         }
    
25.       }
    
26.     }
    
27.   }

复制代码

通过此修改，您可以连接到HID设备。以BLE手机远程快门为例，每次按下按钮，都会执行notifyCB（）并获取数据

1. void notifyCB(NimBLERemoteCharacteristic *pRemoteCharacteristic, uint8_t *pData, size_t length, bool isNotify) {
   
2.   std::string str = (isNotify == true) ? "Notification" : "Indication";
   
3.   str += " from ";
   
4.   str += pRemoteCharacteristic->getRemoteService()->getClient()->getPeerAddress().toString();
   
5.   str += ": Service = " + pRemoteCharacteristic->getRemoteService()->getUUID().toString();
   
6.   str += ", Characteristic = " + pRemoteCharacteristic->getUUID().toString();
   
7.   Serial.print(str.c_str());
   
8.   Serial.print("\ndata: ");
   
9.   for (int i = 0; i < length; i++) {
   
10. //将uint8_t显示为头0的字符串

复制代码

顺便说一句，如果它是BLE HID设备，则可以连接任何设备，我认为最好在实际操作时检查name或address

M5StickC中的操作
现在您可以从HID设备获取输入数据，尝试操作M5StickC，由于红色LED已连接到GPIO10，让我们使其闪烁，按下远程快门上的iOS按钮（大）

1. Notification from ff:ff:c3:19:fa:0b: Service = 0x1812, Characteristic = 0x2a4d
   
2. data: 01 00
   
3. Notification from ff:ff:c3:19:fa:0b: Service = 0x1812, Characteristic = 0x2a4d
   
4. data: 00 00

复制代码

当您按下android按钮（小）时

1. Notification from ff:ff:c3:19:fa:0b: Service = 0x1812, Characteristic = 0x2a4d
   
2. data: 00 28
   
3. Notification from ff:ff:c3:19:fa:0b: Service = 0x1812, Characteristic = 0x2a4d
   
4. data: 01 00
   
5. Notification from ff:ff:c3:19:fa:0b: Service = 0x1812, Characteristic = 0x2a4d
   
6. data: 00 00
   
7. Notification from ff:ff:c3:19:fa:0b: Service = 0x1812, Characteristic = 0x2a4d
   
8. data: 00 00

复制代码

数据将以这种方式发送，因此当00 28,01 00到来时，打开LED，收到01 00时我将其关闭

1. // //点亮后标记跳过01 00
   
2. bool on = false;
   
3. 
   
4. /** Notification / Indication receiving handler callback */
   
5. void notifyCB(NimBLERemoteCharacteristic *pRemoteCharacteristic, uint8_t *pData, size_t length, bool isNotify) {
   
6. Serial.print("data: ");
   
7.   for (int i = 0; i < length; i++) {
   
8.     // 将uint8_t显示为头0的字符串
   
9.     Serial.printf("%02X ", pData[i]);
   
10.   }
    
11.   Serial.print("\n");
    
12.   if (pData[1] & 0x28) {
    
13.     //如果00 28，请打开LED并设置一个标志
    
14.     digitalWrite(GPIO_NUM_10, LOW);
    
15.     on = true;
    
16.   }
    
17.   if (pData[0] & 0x01) {
    
18.     // 如果设置了标志（立即在00 28之后），请跳过它。
    
19.     if (on) {
    
20.     on = false;
    
21.     return;
    
22.   }
    
23. //关闭LED
    
24.     digitalWrite(GPIO_NUM_10, HIGH);
    
25.   }
    
26. 
    
27. }

复制代码

顺便说一下，草图的大小为42％，比Arduino-BLE小得多。也许Arduino-BLE的使用率将达到70％到80％...

完整代码

1. /** NimBLE_Server Demo:
   
2. *
   
3. *  Demonstrates many of the available features of the NimBLE client library.
   
4. *  
   
5. *  Created: on March 24 2020
   
6. *      Author: H2zero
   
7. *
   
8. */
   
9. 
   
10. #include <NimBLEDevice.h>
    
11. #include <M5StickC.h>
    
12. 
    
13. 
    
14. #include <vector>
    
15. using namespace std;
    
16. 
    
17. void scanEndedCB(NimBLEScanResults results);
    
18. 
    
19. // UUID HID
    
20. static NimBLEUUID serviceUUID("1812");
    
21. // UUID Report Charcteristic
    
22. static NimBLEUUID charUUID("2a4d");
    
23. 
    
24. static NimBLEAdvertisedDevice *advDevice;
    
25. 
    
26. static bool doConnect = false;
    
27. static uint32_t scanTime = 0; /** 0 = scan forever */
    
28. 
    
29. /**  None of these are required as they will be handled by the library with defaults. **
    
30. **                       Remove as you see fit for your needs                        */
    
31. class ClientCallbacks: public NimBLEClientCallbacks {
    
32.   void onConnect(NimBLEClient *pClient) {
    
33.     Serial.println("Connected");
    
34.     /** After connection we should change the parameters if we don't need fast response times.
    
35.      *  These settings are 150ms interval, 0 latency, 450ms timout.
    
36.      *  Timeout should be a multiple of the interval, minimum is 100ms.
    
37.      *  I find a multiple of 3-5 * the interval works best for quick response/reconnect.
    
38.      *  Min interval: 120 * 1.25ms = 150, Max interval: 120 * 1.25ms = 150, 0 latency, 60 * 10ms = 600ms timeout
    
39.      */
    
40.     pClient->updateConnParams(120, 120, 0, 60);
    
41.   }
    
42.   ;
    
43. 
    
44.   void onDisconnect(NimBLEClient *pClient) {
    
45.     Serial.print(pClient->getPeerAddress().toString().c_str());
    
46.     Serial.println(" Disconnected - Starting scan");
    
47.     NimBLEDevice::getScan()->start(scanTime, scanEndedCB);
    
48.   }
    
49.   ;
    
50. 
    
51.   /** Called when the peripheral requests a change to the connection parameters.
    
52.    *  Return true to accept and apply them or false to reject and keep
    
53.    *  the currently used parameters. Default will return true.
    
54.    */
    
55.   bool onConnParamsUpdateRequest(NimBLEClient *pClient, const ble_gap_upd_params *params) {
    
56.     if (params->itvl_min < 24) { /** 1.25ms units */
    
57.       return false;
    
58.     }
    
59.     else if (params->itvl_max > 40) { /** 1.25ms units */
    
60.       return false;
    
61.     }
    
62.     else if (params->latency > 2) { /** Number of intervals allowed to skip */
    
63.       return false;
    
64.     }
    
65.     else if (params->supervision_timeout > 100) { /** 10ms units */
    
66.       return false;
    
67.     }
    
68. 
    
69.     return true;
    
70.   }
    
71.   ;
    
72. 
    
73.   /********************* Security handled here **********************
    
74.    ****** Note: these are the same return values as defaults ********/
    
75.   uint32_t onPassKeyRequest() {
    
76.     Serial.println("Client Passkey Request");
    
77.     /** return the passkey to send to the server */
    
78.     return 123456;
    
79.   }
    
80.   ;
    
81. 
    
82.   bool onConfirmPIN(uint32_t pass_key) {
    
83.     Serial.print("The passkey YES/NO number: ");
    
84.     Serial.println(pass_key);
    
85.     /** Return false if passkeys don't match. */
    
86.     return true;
    
87.   }
    
88.   ;
    
89. 
    
90.   /** Pairing proces\s complete, we can check the results in ble_gap_conn_desc */
    
91.   void onAuthenticationComplete(ble_gap_conn_desc *desc) {
    
92.     if (!desc->sec_state.encrypted) {
    
93.       Serial.println("Encrypt connection failed - disconnecting");
    
94.       /** Find the client with the connection handle provided in desc */
    
95.       NimBLEDevice::getClientByID(desc->conn_handle)->disconnect();
    
96.       return;
    
97.     }
    
98.   }
    
99.   ;
    
100. };
     
101. 
     
102. /** Define a class to handle the callbacks when advertisments are received */
     
103. class AdvertisedDeviceCallbacks: public NimBLEAdvertisedDeviceCallbacks {
     
104. 
     
105.   void onResult(NimBLEAdvertisedDevice *advertisedDevice) {
     
106.     Serial.print("Advertised Device found: ");
     
107. //        Serial.println(advertisedDevice->toString().c_str());
     
108.     Serial.printf("name:%s,address:%s", advertisedDevice->getName().c_str(), advertisedDevice->getAddress().toString().c_str());
     
109.     Serial.printf("UUID:%s\n", advertisedDevice->haveServiceUUID() ? advertisedDevice->getServiceUUID().toString().c_str() : "none");
     
110. 
     
111.     if (advertisedDevice->isAdvertisingService(serviceUUID)) {
     
112.       Serial.println("Found Our Service");
     
113.       /** stop scan before connecting */
     
114.       NimBLEDevice::getScan()->stop();
     
115.       /** Save the device reference in a global for the client to use*/
     
116.       advDevice = advertisedDevice;
     
117.       /** Ready to connect now */
     
118.       doConnect = true;
     
119.     }
     
120.   }
     
121.   ;
     
122. };
     
123. 
     
124. const uint8_t START = 0x08;
     
125. const uint8_t SELECT = 0x04;
     
126. 
     
127. const int INDEX_BUTTON = 6;
     
128. 
     
129. bool on = false;
     
130. 
     
131. /** Notification / Indication receiving handler callback */
     
132. void notifyCB(NimBLERemoteCharacteristic *pRemoteCharacteristic, uint8_t *pData, size_t length, bool isNotify) {
     
133.   std::string str = (isNotify == true) ? "Notification" : "Indication";
     
134.   str += " from ";
     
135.   str += pRemoteCharacteristic->getRemoteService()->getClient()->getPeerAddress().toString();
     
136.   str += ": Service = " + pRemoteCharacteristic->getRemoteService()->getUUID().toString();
     
137.   str += ", Characteristic = " + pRemoteCharacteristic->getUUID().toString();
     
138. //    str += ", Value = " + std::string((char*)pData, length);
     
139.   Serial.print(str.c_str());
     
140.   Serial.print("\ndata: ");
     
141.   for (int i = 0; i < length; i++) {
     
142.     // uint8_tを頭0のstringで表示する
     
143.     Serial.printf("%02X ", pData[i]);
     
144.   }
     
145.   Serial.print("\n");
     
146.   if (pData[1] & 0x28) {
     
147.     digitalWrite(GPIO_NUM_10, LOW);
     
148.     on = true;
     
149.   }
     
150.   if (pData[0] & 0x01) {
     
151.     if (on) {
     
152.     on = false;
     
153.     return;
     
154.   }
     
155.     digitalWrite(GPIO_NUM_10, HIGH);
     
156.   }
     
157. 
     
158. }
     
159. 
     
160. /** Callback to process the results of the last scan or restart it */
     
161. void scanEndedCB(NimBLEScanResults results) {
     
162.   Serial.println("Scan Ended");
     
163. }
     
164. 
     
165. /** Create a single global instance of the callback class to be used by all clients */
     
166. static ClientCallbacks clientCB;
     
167. 
     
168. /** Handles the provisioning of clients and connects / interfaces with the server */
     
169. bool connectToServer() {
     
170.   NimBLEClient *pClient = nullptr;
     
171. 
     
172.   /** Check if we have a client we should reuse first **/
     
173.   if (NimBLEDevice::getClientListSize()) {
     
174.     /** Special case when we already know this device, we send false as the
     
175.      *  second argument in connect() to prevent refreshing the service database.
     
176.      *  This saves considerable time and power.
     
177.      */
     
178.     pClient = NimBLEDevice::getClientByPeerAddress(advDevice->getAddress());
     
179.     if (pClient) {
     
180.       if (!pClient->connect(advDevice, false)) {
     
181.         Serial.println("Reconnect failed");
     
182.         return false;
     
183.       }
     
184.       Serial.println("Reconnected client");
     
185.     }
     
186.     /** We don't already have a client that knows this device,
     
187.      *  we will check for a client that is disconnected that we can use.
     
188.      */
     
189.     else {
     
190.       pClient = NimBLEDevice::getDisconnectedClient();
     
191.     }
     
192.   }
     
193. 
     
194.   /** No client to reuse? Create a new one. */
     
195.   if (!pClient) {
     
196.     if (NimBLEDevice::getClientListSize() >= NIMBLE_MAX_CONNECTIONS) {
     
197.       Serial.println("Max clients reached - no more connections available");
     
198.       return false;
     
199.     }
     
200. 
     
201.     pClient = NimBLEDevice::createClient();
     
202. 
     
203.     Serial.println("New client created");
     
204. 
     
205.     pClient->setClientCallbacks(&clientCB, false);
     
206.     /** Set initial connection parameters: These settings are 15ms interval, 0 latency, 120ms timout.
     
207.      *  These settings are safe for 3 clients to connect reliably, can go faster if you have less
     
208.      *  connections. Timeout should be a multiple of the interval, minimum is 100ms.
     
209.      *  Min interval: 12 * 1.25ms = 15, Max interval: 12 * 1.25ms = 15, 0 latency, 51 * 10ms = 510ms timeout
     
210.      */
     
211.     pClient->setConnectionParams(12, 12, 0, 51);
     
212.     /** Set how long we are willing to wait for the connection to complete (seconds), default is 30. */
     
213.     pClient->setConnectTimeout(5);
     
214. 
     
215.     if (!pClient->connect(advDevice)) {
     
216.       /** Created a client but failed to connect, don't need to keep it as it has no data */
     
217.       NimBLEDevice::deleteClient(pClient);
     
218.       Serial.println("Failed to connect, deleted client");
     
219.       return false;
     
220.     }
     
221.   }
     
222. 
     
223.   if (!pClient->isConnected()) {
     
224.     if (!pClient->connect(advDevice)) {
     
225.       Serial.println("Failed to connect");
     
226.       return false;
     
227.     }
     
228.   }
     
229. 
     
230.   Serial.print("Connected to: ");
     
231.   Serial.println(pClient->getPeerAddress().toString().c_str());
     
232.   Serial.print("RSSI: ");
     
233.   Serial.println(pClient->getRssi());
     
234. 
     
235.   /** Now we can read/write/subscribe the charateristics of the services we are interested in */
     
236.   NimBLERemoteService *pSvc = nullptr;
     
237. //  NimBLERemoteCharacteristic *pChr = nullptr;
     
238.   std::vector<NimBLERemoteCharacteristic*> *pChrs = nullptr;
     
239. 
     
240.   NimBLERemoteDescriptor *pDsc = nullptr;
     
241. 
     
242.   pSvc = pClient->getService(serviceUUID);
     
243.   if (pSvc) { /** make sure it's not null */
     
244.     pChrs = pSvc->getCharacteristics(true);
     
245.   }
     
246. 
     
247.   if (pChrs) { /** make sure it's not null */
     
248. 
     
249.     for (int i = 0; i < pChrs->size(); i++) {
     
250. 
     
251.       if (pChrs->at(i)->canNotify()) {
     
252.         /** Must send a callback to subscribe, if nullptr it will unsubscribe */
     
253.         if (!pChrs->at(i)->registerForNotify(notifyCB)) {
     
254.           /** Disconnect if subscribe failed */
     
255.           pClient->disconnect();
     
256.           return false;
     
257.         }
     
258.       }
     
259.     }
     
260.   }
     
261. 
     
262.   else {
     
263.     Serial.println("DEAD service not found.");
     
264.   }
     
265. 
     
266.   Serial.println("Done with this device!");
     
267.   return true;
     
268. }
     
269. 
     
270. void setup() {
     
271.   Serial.begin(115200);
     
272.   Serial.println("Starting NimBLE Client");
     
273.   M5.begin();
     
274.   pinMode(GPIO_NUM_10, OUTPUT);
     
275.   digitalWrite(GPIO_NUM_10, HIGH);
     
276. 
     
277.   /** Initialize NimBLE, no device name spcified as we are not advertising */
     
278.   NimBLEDevice::init("");
     
279. 
     
280.   /** Set the IO capabilities of the device, each option will trigger a different pairing method.
     
281.    *  BLE_HS_IO_KEYBOARD_ONLY    - Passkey pairing
     
282.    *  BLE_HS_IO_DISPLAY_YESNO   - Numeric comparison pairing
     
283.    *  BLE_HS_IO_NO_INPUT_OUTPUT - DEFAULT setting - just works pairing
     
284.    */
     
285. //NimBLEDevice::setSecurityIOCap(BLE_HS_IO_KEYBOARD_ONLY); // use passkey
     
286. //NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_YESNO); //use numeric comparison
     
287.   /** 2 different ways to set security - both calls achieve the same result.
     
288.    *  no bonding, no man in the middle protection, secure connections.
     
289.    *
     
290.    *  These are the default values, only shown here for demonstration.
     
291.    */
     
292. //NimBLEDevice::setSecurityAuth(false, false, true);
     
293.   NimBLEDevice::setSecurityAuth(/*BLE_SM_PAIR_AUTHREQ_BOND | BLE_SM_PAIR_AUTHREQ_MITM |*/BLE_SM_PAIR_AUTHREQ_SC);
     
294. 
     
295.   /** Optional: set the transmit power, default is 3db */
     
296.   NimBLEDevice::setPower(ESP_PWR_LVL_P9); /** +9db */
     
297. 
     
298.   /** Optional: set any devices you don't want to get advertisments from */
     
299. // NimBLEDevice::addIgnored(NimBLEAddress ("aa:bb:cc:dd:ee:ff"));
     
300.   /** create new scan */
     
301.   NimBLEScan *pScan = NimBLEDevice::getScan();
     
302. 
     
303.   /** create a callback that gets called when advertisers are found */
     
304.   pScan->setAdvertisedDeviceCallbacks(new AdvertisedDeviceCallbacks());
     
305. 
     
306.   /** Set scan interval (how often) and window (how long) in milliseconds */
     
307.   pScan->setInterval(10000);
     
308.   pScan->setWindow(9999);
     
309. 
     
310.   /** Active scan will gather scan response data from advertisers
     
311.    *  but will use more energy from both devices
     
312.    */
     
313.   pScan->setActiveScan(true);
     
314.   /** Start scanning for advertisers for the scan time specified (in seconds) 0 = forever
     
315.    *  Optional callback for when scanning stops.
     
316.    */
     
317.   pScan->start(scanTime, scanEndedCB);
     
318. }
     
319. 
     
320. void loop() {
     
321.   M5.update();
     
322.   if (M5.BtnA.wasReleased()) {
     
323.     M5.Axp.PowerOff();
     
324.   }
     
325.   while (!doConnect) {
     
326.     M5.update();
     
327.     if (M5.BtnA.wasReleased()) {
     
328.       M5.Axp.PowerOff();
     
329.     }
     
330.     delay(1);
     
331.   }
     
332. 
     
333.   doConnect = false;
     
334. 
     
335.   /** Found a device we want to connect to, do it now */
     
336.   if (connectToServer()) {
     
337.     Serial.println("Success! we should now be getting notifications, scanning for more!");
     
338.   }
     
339.   else {
     
340.     Serial.println("Failed to connect, starting scan");
     
341.   }
     
342. 
     
343. //    NimBLEDevice::getScan()->start(scanTime,scanEndedCB);
     
344. }

复制代码