कण शक्तिशाली ब्लूटूथ एपीआई का उपयोग कैसे करें

यह पोस्ट मूल रूप से www.jaredwolff.com की है

मैं हार गया।

मैंने पूरी रात ब्लूटूथ लो एनर्जी प्रोजेक्ट को काम करने की कोशिश में बिताई थी। यह दर्दनाक था। यह निराशाजनक था। मैं हार मानने को तैयार था।

वह ब्लूटूथ लो एनर्जी के शुरुआती दिनों में था। तब से इसे विकसित करना आसान और आसान हो गया है। पार्टिकल मेश ब्लूटूथ लाइब्रेरी कोई अपवाद नहीं है।

इस वॉकथ्रू में, मैं आपको दिखाऊंगा कि पार्टिकल के ब्लूटूथ एपीआई का उपयोग कैसे किया जाता है। हम कुछ एल ई डी कॉन्फ़िगर करेंगे और उन्हें मेश नेटवर्क के सभी उपकरणों पर बदलते हुए देखेंगे। हम एक आर्गन और क्सीनन बोर्ड का उपयोग करेंगे।

तैयार? आइए शुरू करें!

पी.एस. यह पोस्ट लंबी है। यदि आप कुछ डाउनलोड करना चाहते हैं, तो सुंदर स्वरूपित PDF के लिए यहां क्लिक करें।

चरण 1:ब्लूटूथ सेट करना

कण कार्यक्षेत्र को डाउनलोड/इंस्टॉल करें
एक नया प्रोजेक्ट बनाएं। मैंने एक उपयुक्त स्थान चुना और फिर उसका नाम ble_mesh . रखा
अपने /src/ पर जाएं direcory और अपना <your project name>.ino open खोलें फ़ाइल
फिर सुनिश्चित करें कि आपने अपने डिवाइसओएस के संस्करण को> 1.3.0 . में बदल दिया है

कोड लिखें

हम 3 विशेषताओं के साथ एक सेवा स्थापित करना चाहते हैं। विशेषताएँ क्रमशः RGB LED की तीव्रता से संबंधित हैं। यहां अपना ब्लूटूथ सेट अप करने का तरीका बताया गया है:

आपके Setup() . में फ़ंक्शन आपके एलईडी के ऐप नियंत्रण को सक्षम करता है
```
RGB.control(true);
```
अपने UUID को अपने .ino . के शीर्ष पर सेट करें फ़ाइल
```
 const char* serviceUuid = "6E400001-B5A3-F393-E0A9-E50E24DCCA9E";
 const char* red         = "6E400002-B5A3-F393-E0A9-E50E24DCCA9E";
 const char* green       = "6E400003-B5A3-F393-E0A9-E50E24DCCA9E";
 const char* blue        = "6E400004-B5A3-F393-E0A9-E50E24DCCA9E";
```
यूयूआईडी विशिष्ट पहचानकर्ता या पते हैं। उनका उपयोग डिवाइस पर विभिन्न सेवाओं और विशेषताओं में अंतर करने के लिए किया जाता है।

उपरोक्त यूयूआईडी का उपयोग पिछले कण उदाहरणों में किया गया है। अगर आप अपना खुद का बनाना चाहते हैं तो आप uuidgen . का उपयोग कर सकते हैं OSX कमांड लाइन पर। आप ऑनलाइन GUID जेनरेटर जैसी वेबसाइट पर भी जा सकते हैं।

अपना स्वयं का UUID प्राप्त करने के लिए उपरोक्त सेटिंग्स का उपयोग करें। इसके बाद आप इस जेनरेट किए गए एक से अपनी सेवा और विशिष्ट यूयूआईडी बना सकते हैं:
```
 const char* serviceUuid = "b425040**0**-fb4b-4746-b2b0-93f0e61122c6"; //service
 const char* red         = "b4250401-fb4b-4746-b2b0-93f0e61122c6"; //red char
 const char* green       = "b4250402-fb4b-4746-b2b0-93f0e61122c6"; //green char
 const char* blue        = "b4250403-fb4b-4746-b2b0-93f0e61122c6"; //blue char
```
ऐसा करने का कोई सही या गलत तरीका नहीं है। लेकिन आपको सावधान रहना होगा कि आप ब्लूटूथ एसआईजी द्वारा आरक्षित यूयूआईडी का उपयोग नहीं कर रहे हैं। यह अत्यधिक संभावना नहीं है। अगर आप दोबारा जांच करना चाहते हैं तो आप यहां और यहां जा सकते हैं।

अभी के लिए, हम UUIDs के पहले सेट के साथ बने रहेंगे।
Setup() . में , अपनी सेवा आरंभ करें।
```
 // Set the RGB BLE service
 BleUuid rgbService(serviceUuid);
```
यह आपकी सेवा का "पंजीकरण' करने का पहला चरण है। इस पर और अधिक जानकारी नीचे दी गई है।
Setup() . में प्रत्येक विशेषता को प्रारंभ करें
```
 BleCharacteristic redCharacteristic("red", BleCharacteristicProperty::WRITE_WO_RSP, red, serviceUuid, onDataReceived, (void*)red);
 BleCharacteristic greenCharacteristic("green", BleCharacteristicProperty::WRITE_WO_RSP, green, serviceUuid, onDataReceived, (void*)green);
 BleCharacteristic blueCharacteristic("blue", BleCharacteristicProperty::WRITE_WO_RSP, blue, serviceUuid, onDataReceived, (void*)blue);
```
इस सेटअप के लिए, हम WRITE_WO_RSP . का उपयोग करने जा रहे हैं संपत्ति। यह हमें डेटा लिखने और कोई प्रतिक्रिया नहीं की उम्मीद करने की अनुमति देता है।
मैंने यूयूआईडी को अगले दो पैरामीटर के रूप में संदर्भित किया है। पहली विशेषता UUID है। दूसरी सेवा UUID है।

अगला पैरामीटर कॉलबैक फ़ंक्शन है। जब इस कॉलबैक में डेटा लिखा जाता है, तो यह फ़ंक्शन सक्रिय हो जाएगा।

अंत में अंतिम पैरामीटर संदर्भ है। इसका वास्तव में क्या मतलब है? हम तीनों विशेषताओं के लिए समान कॉलबैक का उपयोग कर रहे हैं। एक ही तरीका है कि हम यह जान सकते हैं कि कौन सी विशेषता (कम से कम डिवाइसओएस में) लिखी गई थी, एक संदर्भ सेट करके है। इस मामले में हम पहले से उपलब्ध यूयूआईडी का उपयोग करने जा रहे हैं।
विशेषताओं को परिभाषित करने के ठीक बाद, आइए उन्हें जोड़ते हैं ताकि वे दिखाई दें:
```
 // Add the characteristics
 BLE.addCharacteristic(redCharacteristic);
 BLE.addCharacteristic(greenCharacteristic);
 BLE.addCharacteristic(blueCharacteristic);
```
कॉलबैक फ़ंक्शन सेट करें।
```
 // Static function for handling Bluetooth Low Energy callbacks
 static void onDataReceived(const uint8_t* data, size_t len, const BlePeerDevice& peer, void* context) {

 }
```
आप इसे फ़ाइल के शीर्ष पर (Setup() . से ऊपर) कर सकते हैं ) हम इसे बाद में परिभाषित करेंगे।
अंत में, आपके डिवाइस को कनेक्ट करने योग्य बनाने के लिए, हमें विज्ञापन सेट अप करना होगा। इस कोड को अपने Setup() . के अंत में रखें समारोह
```
 // Advertising data
 BleAdvertisingData advData;

 // Add the RGB LED service
 advData.appendServiceUUID(rgbService);

 // Start advertising!
 BLE.advertise(&advData);
```
सबसे पहले हम एक BleAdvertisingData बनाते हैं वस्तु। हम rgbService जोड़ते हैं चरण 3 से। अंत में, हम विज्ञापन शुरू कर सकते हैं ताकि हमारी सेवा और विशेषताओं को खोजा जा सके!

परीक्षण का समय

इस बिंदु पर हमारे पास एक न्यूनतम व्यवहार्य कार्यक्रम है। आइए इसे संकलित करें और इसे हमारे पार्टिकल हार्डवेयर में प्रोग्राम करें। यह किसी भी मेष सक्षम डिवाइस के साथ काम करना चाहिए। (क्सीनन, आर्गन, बोरॉन)

परीक्षण शुरू करने से पहले, अस्थायी रूप से SYSTEM_MODE(MANUAL); add जोड़ें आपकी फ़ाइल के शीर्ष पर। यह डिवाइस को मेश नेटवर्क से कनेक्ट होने से रोकेगा। अगर स्टार्टअप पर डिवाइस ब्लिंक कर रहा है, तो जारी रखने से पहले आपको इसे पार्टिकल ऐप के साथ सेट करना होगा।
यहां 1.3.0-rc.1 छवि डाउनलोड करें। क्सीनन के लिए, आपको [email protected]. की आवश्यकता होगी। दूसरों के लिए [email protected] . देखें और [email protected]. फ़ाइलें पृष्ठ के निचले भाग में संपत्ति . के अंतर्गत हैं
अपने डिवाइस को DFU मोड में डालें। मोड बटन दबाए रखें और क्षण भर के लिए रीसेट करें . क्लिक करें बटन. मोड बटन को दबाए रखें जब तक एलईडी पीले रंग की न हो जाए।
कमांड लाइन विंडो में, निर्देशिकाओं को उस स्थान पर बदलें जहां आपने डाउनलोड की गई फ़ाइल को संग्रहीत किया था। मेरे मामले में कमांड cd ~/Downloads/ . है
फिर दौड़ें:
```
 particle flash --usb [email protected]
```
यह आपके क्सीनन में नवीनतम ओएस स्थापित करेगा। एक बार यह हो जाने के बाद यह तेजी से पीले रंग में झपकाता रहेगा। फिर से अगर आपके पास एक अलग पार्टिकल मेश डिवाइस है, तो मिलान करने के लिए फ़ाइल नाम बदलें।
विज़ुअल कोड में, कमांड + शिफ्ट + पी . का उपयोग करें कमांड मेनू को पॉप अप करने के लिए कुंजी संयोजन। कण:संकलन एप्लिकेशन (स्थानीय) . चुनें
पॉप अप होने वाली किसी भी त्रुटि को ठीक करें।
फिर, वही मेनू खोलें और फ़्लैश एप्लिकेशन (स्थानीय) . चुनें
जब प्रोग्रामिंग पूरी हो जाए, तो अपने फोन को बाहर निकालें। फिर, अपना पसंदीदा ब्लूटूथ लो एनर्जी ऐप खोलें। सबसे अच्छे हैं NRF Connect और लाइट ब्लू एक्सप्लोरर. मैं इस उदाहरण के लिए लाइट ब्लू एक्सप्लोरर का उपयोग करने जा रहा हूं।
जांचें कि क्या "ज़ेनॉन-" . नाम का कोई उपकरण है विज्ञापन है। डालें आपके डिवाइस के लिए अद्वितीय आईडी के साथ।
अपना उपकरण ढूंढें और नाम पर क्लिक करें।
सेवाओं और विशेषताओं की सूची देखें। क्या इसमें वह सेवा और विशेषता यूयूआईडी शामिल है जो हमने अभी तक निर्धारित की है? उदाहरण के लिए, क्या सेवा UUID 6E400001-B5A3-F393-E0A9-E50E24DCCA9E के रूप में दिखाई देती है ?

यदि सब कुछ आपकी अपेक्षा के अनुरूप दिखाई देता है, तो आप एक अच्छी जगह पर हैं। यदि पहले के निर्देशों को न पढ़ें तो सुनिश्चित करें कि सब कुछ मेल खाता है।

चरण 2:डेटा को संभालना

हमारी परियोजना का अगला चरण लेखन घटनाओं को संसाधित करना है। हम अपने onDataReceived . को अपडेट करते रहेंगे समारोह।

कोड लिखें

सबसे पहले, आइए एक संरचना बनाएं जो एल ई डी की स्थिति को बनाए रखे। यह फ़ाइल के शीर्ष पर किया जा सकता है।
```
 // Variables for keeping state
 typedef struct {
   uint8_t red;
   uint8_t green;
   uint8_t blue;
 } led_level_t;
```
इसका दूसरा भाग इस डेटा प्रकार का उपयोग करके एक स्थिर चर बनाना है
```
 // Static level tracking
 static led_level_t m_led_level;
```
पहले दो चरण हमें RGB LED के तीन मानों का प्रतिनिधित्व करने के लिए एक एकल चर का उपयोग करने की अनुमति देते हैं।
इसके बाद, आइए onDataReceive . के अंदर बुनियादी त्रुटियों की जांच करें फ़ंक्शन उदाहरण के लिए हम यह सुनिश्चित करना चाहते हैं कि हमें केवल एक बाइट प्राप्त हो रही है।
```
 // We're only looking for one byte
   if( len != 1 ) {
     return;
 	}
```
इसके बाद, हम देखना चाहते हैं कि यह घटना किस विशेषता से आई है। हम context . का उपयोग कर सकते हैं इसे निर्धारित करने के लिए चर।
```
 // Sets the global level
   if( context == red ) {
     m_led_level.red = data[0];
   } else if ( context == green ) {
     m_led_level.green = data[0];
   } else if ( context == blue ) {
     m_led_level.blue = data[0];
   }
```
याद रखें, इस मामले में संदर्भ लाल, हरे या नीले यूयूआईडी स्ट्रिंग के सूचक के बराबर होगा। आप यह भी देख सकते हैं कि हम m_led_level . सेट कर रहे हैं . इस तरह हम आरजीबी एलईडी को अपडेट कर सकते हैं, भले ही केवल एक मान बदल गया हो।
अंत में, एक बार सेट हो जाने पर, आप RGB . पर लिख सकते हैं वस्तु
```
 // Set RGB color
 	RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue);
```

कोड का परीक्षण करें

आइए डिवाइस को फ्लैश करने के लिए पहले की तरह ही प्रक्रिया से गुजरें।

अपने डिवाइस को DFU मोड में डालें। मोड बटन दबाए रखें और रीसेट करें . क्लिक करें बटन. मोड बटन को दबाए रखें जब तक एलईडी पीले रंग की न हो जाए।
फिर, वही मेनू खोलें और फ़्लैश एप्लिकेशन (स्थानीय) . चुनें
प्रोग्रामिंग हो जाने के बाद, लाइट ब्लू एक्सप्लोरर . का उपयोग करके डिवाइस से कनेक्ट करें ।
लाल एलईडी पर लागू होने वाली विशेषता पर टैप करें।
FF लिखें . लाल एलईडी चालू होनी चाहिए।
00 लिखें . लाल एलईडी बंद होनी चाहिए।
अन्य दो विशेषताओं के लिए भी ऐसा ही करें। अब हमारे पास ब्लूटूथ लो एनर्जी पर RGB LED का पूरा नियंत्रण है!

चरण 3:मेष के माध्यम से साझा करना

अंत में, अब जब हम सफलतापूर्वक बीएलई संदेश प्राप्त कर रहे हैं, तो उन्हें हमारे जाल नेटवर्क पर अग्रेषित करने का समय आ गया है।

कोड लिखें

सबसे पहले MANUAL मोड को हटाते हैं। कमेंट आउट करें SYSTEM_MODE(MANUAL);
फ़ाइल के शीर्ष पर एक वेरिएबल जोड़ें जिसे हम ट्रैक करने के लिए उपयोग करेंगे यदि हमें प्रकाशित करने की आवश्यकता है
```
 // Tracks when to publish to Mesh
 static bool m_publish;
```
फिर इसे Setup() . में इनिशियलाइज़ करें
```
 // Set to false at first
 m_publish = false;
```
फिर, RGB को onDataReceived में ले जाने के बाद सेट करें कॉलबैक, आइए इसे सही सेट करें:
```
 // Set RGB color
 RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue);

 // Set to publish
 m_publish = true;
```
आइए loop() . में एक सशर्त जोड़ें समारोह। यह हमें एलईडी स्थिति को मेश नेटवर्क पर प्रकाशित करने के लिए प्रेरित करेगा:
```
 if( m_publish ) {
 	// Reset flag
 	m_publish = false;

 	// Publish to Mesh
   Mesh.publish("red", String::format("%d", m_led_level.red));
   Mesh.publish("green", String::format("%d", m_led_level.green));
   Mesh.publish("blue", String::format("%d", m_led_level.blue));
 }
```
Mesh.publish दोनों इनपुट के लिए एक स्ट्रिंग की आवश्यकता है। इस प्रकार, हम String::format . का उपयोग कर रहे हैं हमारे लाल, हरे और नीले मानों के साथ एक स्ट्रिंग बनाने के लिए।
तो चलिए Setup() . में उन्हीं वेरिएबल्स की सदस्यता लेते हैं . इस तरह कोई अन्य डिवाइस इस डिवाइस की एलईडी को भी अपडेट कर सकता है।
```
 Mesh.subscribe("red", meshHandler);
 Mesh.subscribe("green", meshHandler);
 Mesh.subscribe("blue", meshHandler);
```
फ़ाइल के शीर्ष पर हम meshHandler बनाना चाहते हैं
```
 // Mesh event handler
 static void meshHandler(const char *event, const char *data)
 {
 }
```
इस एप्लिकेशन में, हमें event . की आवश्यकता है पैरामीटर और data पैरामीटर। उनका उपयोग करने के लिए, हमें उन्हें String . में बदलना होगा प्रकार। इस तरह हम अंतर्निर्मित रूपांतरण और तुलना कार्यों का उपयोग कर सकते हैं। तो, meshHandler . के अंदर फंक्शन ऐड:
```
   // Convert to String for useful conversion and comparison functions
   String eventString = String(event);
   String dataString = String(data);
```
अंत में हम कुछ तुलना करते हैं। हम पहले जांचते हैं कि घटना का नाम मेल खाता है या नहीं। फिर हम dataString . का मान सेट करते हैं संबंधित नेतृत्व स्तर तक।
```
   // Determine which event we recieved
   if( eventString.equals("red") ) {
     m_led_level.red = dataString.toInt();
   } else if ( eventString.equals("green") ) {
     m_led_level.green = dataString.toInt();
   } else if ( eventString.equals("blue") ) {
     m_led_level.blue = dataString.toInt();
   } else {
 		return;
 	}

   // Set RGB color
   RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue);
```
फिर अंत में हम नया RGB रंग सेट करते हैं। ध्यान दें कि मैं return . जोड़कर किसी अज्ञात स्थिति को कैसे संभालता हूं else में स्टेटमेंट खंड। कहर बरपाने से पहले त्रुटि स्थितियों को फ़िल्टर करना हमेशा अच्छा होता है!

कोड का परीक्षण करें

अपने फ़ोन पर पार्टिकल ऐप खोलें
आइए पहले आर्गन को सेट करें। यदि यह नीला नहीं झपका रहा है, तो मोड बटन को तब तक दबाए रखें जब तक कि यह नीला न हो जाए।

नोट:यदि आपने पहले ही ऐप को प्रोग्राम कर लिया है, तो एलईडी डिफ़ॉल्ट रूप से बंद हो जाएगी। मोड बटन को 5 सेकंड तक दबाए रखें और फिर जारी रखें।
युग्मन प्रक्रिया से गुजरें। ऐप आपको सभी चरणों के बावजूद चलता है। सुनिश्चित करें कि आपको अपने मेश नेटवर्क के लिए व्यवस्थापक पासवर्ड याद है।
नवीनतम फर्मवेयर (1.3.0) के साथ एक आर्गन प्रोग्राम करें (देखें चरण 1 - परीक्षण का समय - चरण 2 यह कैसे करना है पर एक अनुस्मारक के लिए)
एक बार तेजी से पीले होने के बाद, आर्गन को टिंकर ऐप के साथ प्रोग्राम करें। आप इसे रिलीज पेज पर डाउनलोड कर सकते हैं।
एक बार जब हमारे पास एक अच्छा ठोस सियान एलईडी (कण बादल से जुड़ा) होगा तो हम ऐप को प्रोग्राम करेंगे। क्लाउड फ्लैश का प्रयोग करें ड्रॉप डाउन मेनू में विकल्प।

जहां तक मैं बता सकता हूं, क्लाउड से कनेक्ट होने पर कण किसी भी डिवाइस को स्थानीय रूप से सुरक्षित मोड में फ्लैश करता है। यह मेरा सेटअप हो सकता है। आपका माइलेज यहां भिन्न हो सकता है। उपयोग करने के लिए सर्वश्रेष्ठ क्लाउड फ्लैश ।

सुनिश्चित करें कि आपने सही डिवाइसओएस संस्करण का चयन किया है (1.3.0-rc1 ), डिवाइस प्रकार (आर्गन ) और डिवाइस का नाम (सेटअप के दौरान आपने इसे क्या नाम दिया )
फ़ोन ऐप . का उपयोग करके क्सीनन से कनेक्ट करें
फ़ोन ऐप का उपयोग करके क्सीनन को अपने मेष नेटवर्क से कनेक्ट करें
क्लाउड फ्लैश . का उपयोग करके अपने क्सीनन को फ्लैश करें . उस नाम का उपयोग करें जिसे आपने फ़ोन ऐप सेटअप के दौरान दिया था। जब तक डिवाइस पार्टिकल क्लाउड या सुरक्षित मोड (पर्पल एलईडी) से जुड़ा है, तब तक इसे प्रोग्राम करना चाहिए।
एक बार कनेक्ट होने के बाद, चलिए मज़ेदार भाग पर आते हैं। लाइट ब्लू एक्सप्लोरर खोलें। या तो आर्गन . से कनेक्ट करें या क्सीनन ।
एलईडी विशेषताओं में से एक का चयन करें और मान बदलें।

एलईडी सभी उपकरणों पर बदलनी चाहिए!

अंतिम कोड

यहाँ अंतिम कोड है जिसमें सभी टुकड़े एक साथ रखे गए हैं। आप इसका उपयोग यह सुनिश्चित करने के लिए कर सकते हैं कि आपने उन्हें सही जगह पर रखा है !!

/*
 * Project ble_mesh
 * Description: Bluetooth Low Energy + Mesh Example
 * Author: Jared Wolff
 * Date: 7/13/2019
 */

//SYSTEM_MODE(MANUAL);

// UUIDs for service + characteristics
const char* serviceUuid = "6E400001-B5A3-F393-E0A9-E50E24DCCA9E";
const char* red         = "6E400002-B5A3-F393-E0A9-E50E24DCCA9E";
const char* green       = "6E400003-B5A3-F393-E0A9-E50E24DCCA9E";
const char* blue        = "6E400004-B5A3-F393-E0A9-E50E24DCCA9E";

// Set the RGB BLE service
BleUuid rgbService(serviceUuid);

// Variables for keeping state
typedef struct {
  uint8_t red;
  uint8_t green;
  uint8_t blue;
} led_level_t;

// Static level tracking
static led_level_t m_led_level;

// Tracks when to publish to Mesh
static bool m_publish;

// Mesh event handler
static void meshHandler(const char *event, const char *data)
{

  // Convert to String for useful conversion and comparison functions
  String eventString = String(event);
  String dataString = String(data);

  // Determine which event we recieved
  if( eventString.equals("red") ) {
    m_led_level.red = dataString.toInt();
  } else if ( eventString.equals("green") ) {
    m_led_level.green = dataString.toInt();
  } else if ( eventString.equals("blue") ) {
    m_led_level.blue = dataString.toInt();
  } else {
		return;
	}

  // Set RGB color
  RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue);

}

// Static function for handling Bluetooth Low Energy callbacks
static void onDataReceived(const uint8_t* data, size_t len, const BlePeerDevice& peer, void* context) {

  // We're only looking for one byte
  if( len != 1 ) {
    return;
  }

  // Sets the global level
  if( context == red ) {
    m_led_level.red = data[0];
  } else if ( context == green ) {
    m_led_level.green = data[0];
  } else if ( context == blue ) {
    m_led_level.blue = data[0];
  }

  // Set RGB color
  RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue);

  // Set to publish
  m_publish = true;

}

// setup() runs once, when the device is first turned on.
void setup() {

  // Enable app control of LED
  RGB.control(true);

  // Init default level
  m_led_level.red = 0;
  m_led_level.green = 0;
  m_led_level.blue = 0;

  // Set to false at first
  m_publish = false;

  // Set the subscription for Mesh updates
  Mesh.subscribe("red",meshHandler);
  Mesh.subscribe("green",meshHandler);
  Mesh.subscribe("blue",meshHandler);

  // Set up characteristics
  BleCharacteristic redCharacteristic("red", BleCharacteristicProperty::WRITE_WO_RSP, red, serviceUuid, onDataReceived, (void*)red);
  BleCharacteristic greenCharacteristic("green", BleCharacteristicProperty::WRITE_WO_RSP, green, serviceUuid, onDataReceived, (void*)green);
  BleCharacteristic blueCharacteristic("blue", BleCharacteristicProperty::WRITE_WO_RSP, blue, serviceUuid, onDataReceived, (void*)blue);

  // Add the characteristics
  BLE.addCharacteristic(redCharacteristic);
  BLE.addCharacteristic(greenCharacteristic);
  BLE.addCharacteristic(blueCharacteristic);

  // Advertising data
  BleAdvertisingData advData;

  // Add the RGB LED service
  advData.appendServiceUUID(rgbService);

  // Start advertising!
  BLE.advertise(&advData);
}

// loop() runs over and over again, as quickly as it can execute.
void loop() {

  // Checks the publish flag,
  // Publishes to a variable called "red" "green" and "blue"
  if( m_publish ) {

    // Reset flag
    m_publish = false;

    // Publish to Mesh
    Mesh.publish("red", String::format("%d", m_led_level.red));
    Mesh.publish("green", String::format("%d", m_led_level.green));
    Mesh.publish("blue", String::format("%d", m_led_level.blue));
  }

}

निष्कर्ष

इस ट्यूटोरियल में आपने सीखा कि पार्टिकल मेश प्रोजेक्ट में ब्लूटूथ कैसे जोड़ा जाता है। जैसा कि आप कल्पना कर सकते हैं, संभावनाएं अनंत हैं। उदाहरण के लिए आप अनुभव में उपयोगकर्ता/प्रशासनिक ऐप्स जोड़ सकते हैं। अब यह बहुत बढ़िया है। ?

आप मेरी आने वाली किताब में इस तरह की और सामग्री की उम्मीद कर सकते हैं:द अल्टीमेट गाइड टू पार्टिकल मेश . अपडेट और अंदरूनी सामग्री के लिए मेरी सूची की सदस्यता लें। साथ ही सभी शुरुआती ग्राहकों को इसके रिलीज़ होने पर छूट मिलती है! साइन अप करने के लिए यहां क्लिक करें।