Particle के ब्लूटूथ API में महारत हासिल करें: चरण-दर-चरण गाइड

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

मैं हार गया था।

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

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

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

तैयार? चलिए शुरू करते हैं!

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

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

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

कोड लिखें

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

अपने Setup() फ़ंक्शन में अपने LED का ऐप कंट्रोल सक्षम करें
```
RGB.control(true); 
```
अपनी .ino फ़ाइल के शीर्ष पर अपने UUID सेट करें
```
 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"; 
```
UUID अद्वितीय पहचानकर्ता या पते हैं। उनका उपयोग डिवाइस पर विभिन्न सेवाओं और विशेषताओं को अलग करने के लिए किया जाता है।

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

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

अभी के लिए, हम पहले सेट UUID के साथ रहेंगे।
Setup() में, अपनी सर्विस इनिशियलाइज़ करें।
```
 // RGB BLE सर्विस सेट करें 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 है। दूसरा सर्विस UUID है।

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

अंतिम पैरामीटर संदर्भ है। इसका वास्तव में क्या अर्थ है? हम सभी तीन विशेषताओं के लिए एक ही कॉलबैक का उपयोग कर रहे हैं। यह जानने का एकमात्र तरीका कि किस विशेषता को लिखा गया था (कम से कम deviceOS में) एक संदर्भ सेट करके है। इस मामले में हम पहले से उपलब्ध UUID का उपयोग करने जा रहे हैं।
विशेषताओं को परिभाषित करने के ठीक बाद, आइए उन्हें जोड़ें ताकि वे दिखाई दें:
```
 // विशेषताओं को जोड़ें BLE.addCharacteristic(redCharacteristic); BLE.addCharacteristic(greenCharacteristic); BLE.addCharacteristic(blueCharacteristic); 
```
कॉलबैक फ़ंक्शन सेट करें।
```
 // ब्लूटूथ लो एनर्जी कॉलबैक को संभालने के लिए स्टैटिक फ़ंक्शन static void onDataReceived(const uint8_t* data, size_t len, const BlePeerDevice& peer, void* context) { } 
```
आप इसे फ़ाइल के शीर्ष पर कर सकते हैं (Setup() के ऊपर) हम इसे बाद में और परिभाषित करेंगे।
अंत में, अपने डिवाइस को कनेक्टेबल बनाने के लिए, हमें विज्ञापन सेट करना होगा। इस कोड को अपने Setup() फ़ंक्शन के अंत में रखें
```
 // विज्ञापन डेटा BleAdvertisingData advData; // RGB LED सर्विस जोड़ें advData.appendServiceUUID(rgbService); // विज्ञापन शुरू करें! BLE.advertise(&advData); 
```
सबसे पहले हम एक BleAdvertisingData ऑब्जेक्ट बनाते हैं। हम चरण 3 से rgbService जोड़ते हैं। अंत में, हम विज्ञापन शुरू कर सकते हैं ताकि हमारी सर्विस और विशेषताएं खोजी जा सकें!

टेस्ट करने का समय

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

टेस्ट शुरू करने से पहले, अस्थायी रूप से अपनी फ़ाइल के शीर्ष पर SYSTEM_MODE(MANUAL); जोड़ें। यह डिवाइस को मेश नेटवर्क से कनेक्ट होने से रोकेगा। यदि डिवाइस स्टार्टअप पर नीला ब्लिंक कर रहा है, तो आपको जारी रखने से पहले Particle ऐप से इसे सेटअप करना होगा।
1.3.0-rc.1 इमेज यहां डाउनलोड करें। Xenon के लिए, आपको xenon-system-part1@1.3.0-rc.1.bin. की आवश्यकता होगी। दूसरों के लिए boron-system-part1@1.3.0-rc.1.bin और argon-system-part1@1.3.0-rc.1.bin. देखें। फ़ाइलें पेज के नीचे Assets के तहत हैं
अपने डिवाइस को DFU मोड में डालें। मोड बटन दबाए रखें और क्षण भर के लिए रीसेट बटन दबाएं। मोड बटन को तब तक दबाए रखें जब तक LED पीला ब्लिंक न करने लगे।
कमांड लाइन विंडो में, उस डायरेक्टरी में बदलें जहां आपने डाउनलोड की गई फ़ाइल स्टोर की है। मेरे मामले में कमांड है cd ~/Downloads/
फिर चलाएं:
```
 particle flash --usb xenon-system-part1@1.3.0-rc.1.bin 
```
यह आपके Xenon पर नवीनतम OS इंस्टॉल करेगा। एक बार हो जाने पर यह तेजी से पीला ब्लिंक करना जारी रखेगा। फिर से यदि आपके पास एक अलग Particle मेश डिवाइस है, तो फ़ाइलनाम को मिलान करने के लिए बदलें।
Visual Code में, कमांड मेनू को पॉप अप करने के लिए Command + Shift + P की संयोजन का उपयोग करें। Particle: Compile application (local) चुनें
कोई भी त्रुटि ठीक करें जो सामने आ सकती है।
फिर, वही मेनू खोलें और Flash application (local) चुनें
जब प्रोग्रामिंग पूरी हो जाए, तो अपना फोन निकालें। फिर, अपना पसंदीदा ब्लूटूथ लो एनर्जी ऐप खोलें। सबसे अच्छे हैं NRF Connect और Light Blue Explorer. मैं इस उदाहरण के लिए Light Blue Explorer का उपयोग करने जा रहा हूं।
जांचें कि "Xenon-" नाम का एक डिवाइस विज्ञापन कर रहा है। अपने डिवाइस के लिए अद्वितीय ID के साथ डालें।
अपना डिवाइस ढूंढें और नाम पर क्लिक करें।
सेवाओं और विशेषताओं की सूची देखें। क्या इसमें अब तक हमारे द्वारा सेट की गई सर्विस और विशेषता UUID शामिल हैं? उदाहरण के लिए, क्या सर्विस UUID 6E400001-B5A3-F393-E0A9-E50E24DCCA9E के रूप में दिखाई देता है?

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

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

हमारी परियोजना का अगला चरण राइट इवेंट को प्रोसेस करना है। हम अपने onDataReceived फ़ंक्शन को अपडेट करेंगे।

कोड लिखें

सबसे पहले, आइए एक स्ट्रक्चर बनाएं जो LED की स्थिति को ट्रैक करे। यह फ़ाइल के शीर्ष पर किया जा सकता है।
```
 // LED की स्थिति ट्रैक करने के लिए वेरिएबल typedef struct { uint8_t red; uint8_t green; uint8_t blue; } led_level_t; 
```
उसका दूसरा भाग इस डेटा प्रकार का उपयोग करके एक स्टैटिक वेरिएबल बनाना है
```
 // स्टैटिक लेवल ट्रैकिंग static led_level_t m_led_level; 
```
पहले दो चरण हमें RGB LED के तीन मूल्यों को दर्शाने के लिए एक सिंगल वेरिएबल का उपयोग करने की अनुमति देते हैं।
अगला, आइए onDataReceive फ़ंक्शन के अंदर बुनियादी त्रुटियों की जांच करें। उदाहरण के लिए हम यह सुनिश्चित करना चाहते हैं कि हम केवल एक बाइट प्राप्त कर रहे हैं।
```
 // हम केवल एक बाइट ढूंढ रहे हैं if( len != 1 ) { return; } 
```
अगला, हम देखना चाहते हैं कि यह इवेंट किस विशेषता से आया है। हम इसे निर्धारित करने के लिए context वेरिएबल का उपयोग कर सकते हैं।
```
 // ग्लोबल लेवल सेट करता है 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]; } 
```
याद रखें, इस मामले में संदर्भ लाल, हरे, या नीले UUID स्ट्रिंग के पॉइंटर के बराबर होगा। आप यह भी नोटिस कर सकते हैं कि हम m_led_level सेट कर रहे हैं। इस तरह हम RGB LED को अपडेट कर सकते हैं भले ही केवल एक मान बदला हो।
अंत में, एक बार सेट हो जाने पर, आप RGB ऑब्जेक्ट पर लिख सकते हैं
```
 // RGB रंग सेट करें RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue); 
```

कोड टेस्ट करें

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

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

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

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

कोड लिखें

सबसे पहले MANUAL मोड हटाएं। SYSTEM_MODE(MANUAL); को कमेंट आउट करें
फ़ाइल के शीर्ष पर एक वेरिएबल जोड़ें जिसका उपयोग हम ट्रैक करने के लिए करेंगे कि हमें पब्लिश करने की आवश्यकता है या नहीं
```
 // मेश पर पब्लिश कब करना है ट्रैक करता है static bool m_publish; 
```

इसे Setup() में इनिशियलाइज़ करें

 // पहले false पर सेट करें m_publish = false;

फिर, onDataReceived कॉलबैक में RGB LED सेट करने के बाद, इसे true पर सेट करें:

 // RGB रंग सेट करें RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue); // पब्लिश करने के लिए सेट करें m_publish = true;

loop() फ़ंक्शन में एक कंडीशनल जोड़ें। यह हमें LED स्थिति को मेश नेटवर्क पर पब्लिश करने का कारण बनेगा:
```
 if( m_publish ) { // फ्लैग रीसेट करें m_publish = false; // मेश पर पब्लिश करें 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() में उन्हीं वेरिएबल को सब्सक्राइब करें। इस तरह दूसरा डिवाइस इस डिवाइस पर LED को अपडेट करने का कारण भी बन सकता है।
```
 Mesh.subscribe("red", meshHandler); Mesh.subscribe("green", meshHandler); Mesh.subscribe("blue", meshHandler); 
```

फ़ाइल के शीर्ष की ओर हम meshHandler बनाना चाहते हैं

 // मेश इवेंट हैंडलर static void meshHandler(const char *event, const char *data) { }

इस एप्लिकेशन में, हमें event पैरामीटर और data पैरामीटर की आवश्यकता है। उनका उपयोग करने के लिए, हमें उन्हें String प्रकार में बदलना होगा। इस तरह हम बिल्ट-इन रूपांतरण और तुलना फ़ंक्शंस का उपयोग कर सकते हैं। तो, meshHandler फ़ंक्शन के अंदर जोड़ें:
```
 // उपयोगी रूपांतरण और तुलना फ़ंक्शंस के लिए String में कनवर्ट करें String eventString = String(event); String dataString = String(data); 
```
अंत में हम कुछ तुलनाएं करते हैं। हम पहले जांचते हैं कि इवेंट नाम मेल खाता है या नहीं। फिर हम dataString के मान को संबंधित LED लेवल पर सेट करते हैं।
```
 // निर्धारित करें कि हमें कौन सा इवेंट प्राप्त हुआ 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; } // RGB रंग सेट करें RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue); 
```
फिर अंत में हम नया RGB रंग सेट करते हैं। ध्यान दें कि मैं else सेक्शन में return स्टेटमेंट जोड़कर अज्ञात स्थिति को कैसे संभालता हूं। त्रुटि की स्थितियों को फ़िल्टर करना हमेशा अच्छा होता है इससे पहले कि वे कहर बरपाएं!

कोड टेस्ट करें

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

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

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

सुनिश्चित करें कि आप सही deviceOS वर्जन (1.3.0-rc1), डिवाइस प्रकार (Argon) और डिवाइस नाम (सेटअप के दौरान आपने इसका क्या नाम रखा) का चयन करते हैं
फोन ऐप का उपयोग करके Xenon से कनेक्ट करें
फोन ऐप का उपयोग करके Xenon को अपने मेश नेटवर्क से कनेक्ट करें
अपने Xenon को Cloud Flash का उपयोग करके फ्लैश करें। फोन ऐप सेटअप के दौरान आपने जो नाम दिया था उसका उपयोग करें। जब तक डिवाइस Particle क्लाउड से जुड़ा है या सेफ मोड में है (बैंगनी LED), यह प्रोग्राम होना चाहिए।
एक बार कनेक्ट होने पर, आइए मजेदार भाग पर पहुंचें। Light Blue Explorer खोलें। Argon या Xenon से कनेक्ट करें।
LED विशेषताओं में से एक का चयन करें और मान बदलें।

LED सभी डिवाइस पर बदलनी चाहिए!

अंतिम कोड

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

/* * Project ble_mesh * Description: Bluetooth Low Energy + Mesh Example * Author: Jared Wolff * Date: 7/13/2019 */ //SYSTEM_MODE(MANUAL); // सर्विस + विशेषताओं के लिए UUIDs 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"; // RGB BLE सर्विस सेट करें BleUuid rgbService(serviceUuid); // स्थिति ट्रैक करने के लिए वेरिएबल typedef struct { uint8_t red; uint8_t green; uint8_t blue; } led_level_t; // स्टैटिक लेवल ट्रैकिंग static led_level_t m_led_level; // मेश पर पब्लिश कब करना है ट्रैक करता है static bool m_publish; // मेश इवेंट हैंडलर static void meshHandler(const char *event, const char *data) { // उपयोगी रूपांतरण और तुलना फ़ंक्शंस के लिए String में कनवर्ट करें String eventString = String(event); String dataString = String(data); // निर्धारित करें कि हमें कौन सा इवेंट प्राप्त हुआ 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; } // RGB रंग सेट करें RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue); } // ब्लूटूथ लो एनर्जी कॉलबैक को संभालने के लिए स्टैटिक फ़ंक्शन static void onDataReceived(const uint8_t* data, size_t len, const BlePeerDevice& peer, void* context) { // हम केवल एक बाइट ढूंढ रहे हैं if( len != 1 ) { return; } // ग्लोबल लेवल सेट करता है 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]; } // RGB रंग सेट करें RGB.color(m_led_level.red, m_led_level.green, m_led_level.blue); // पब्लिश करने के लिए सेट करें m_publish = true; } // setup() एक बार चलता है, जब डिवाइस पहली बार चालू होता है। void setup() { // LED का ऐप कंट्रोल सक्षम करें RGB.control(true); // डिफ़ॉल्ट लेवल इनिशियलाइज़ करें m_led_level.red = 0; m_led_level.green = 0; m_led_level.blue = 0; // पहले false पर सेट करें m_publish = false; // मेश अपडेट के लिए सब्सक्रिप्शन सेट करें Mesh.subscribe("red",meshHandler); Mesh.subscribe("green",meshHandler); Mesh.subscribe("blue",meshHandler); // विशेषताओं को सेट करें 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); // विशेषताओं को जोड़ें BLE.addCharacteristic(redCharacteristic); BLE.addCharacteristic(greenCharacteristic); BLE.addCharacteristic(blueCharacteristic); // विज्ञापन डेटा BleAdvertisingData advData; // RGB LED सर्विस जोड़ें advData.appendServiceUUID(rgbService); // विज्ञापन शुरू करें! BLE.advertise(&advData); } // loop() बार-बार चलता है, जितनी जल्दी हो सके उतनी जल्दी। void loop() { // पब्लिश फ्लैग की जांच करता है, // "red" "green" और "blue" नामक वेरिएबल पर पब्लिश करता है if( m_publish ) { // फ्लैग रीसेट करें m_publish = false; // मेश पर पब्लिश करें 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)); } }

निष्कर्ष

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

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