Particle Argon और Tile Mate: पुश अलर्ट के साथ सरल लोकेशन और प्रेजेंस ट्रैकिंग

कभी किसी प्रोजेक्ट में प्रेजेंस या लोकेशन ट्रैकिंग जोड़ना चाहा? समाधानों (या उनकी कमी) से निराश?

चिंता न करें, आप अकेले नहीं हैं!

इस पोस्ट में आप एक बहुत ही बेसिक ट्रैकिंग और नोटिफिकेशन एप्लिकेशन को लागू करना सीखेंगे। हम Particle Argon और एक Tile Mate का उपयोग करेंगे।

अंत तक आप बता पाएंगे कि Tile मौजूद है या नहीं। साथ ही हम Pushover का उपयोग करके आपकी पसंद के डिवाइस पर पुश नोटिफिकेशन भेजेंगे।

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

नोट शुरू करने से पहले, यह पोस्ट लंबी है। आप इसे बाद में सहेजने और देखने के लिए PDF वर्जन डाउनलोड कर सकते हैं।

प्रारंभिक जांच

Tile का उपयोग करने का विचार पहली नज़र में स्पष्ट नहीं था। आदर्श रूप से, फोन का उपयोग करना अधिक समझ में आता था। दुर्भाग्य से, यह एक व्यवहार्य विकल्प नहीं था। इसके लिए कुछ और शोध और एक ब्लूटूथ iOS ऐप बनाने की आवश्यकता होती।

तो, फोन का विचार बाहर था।

फिर मैंने सोचा, "कौन से डिवाइस हर समय विज्ञापन करते हैं?"

यही वह चीज थी जिसने मुझे Tile जैसे ट्रैकर की राह पर ले जाया।

इसके आने के बाद कुछ प्रथागत परीक्षण हुआ। पहला पड़ाव, Tile एप्लिकेशन।

मैं डिवाइस से कनेक्ट और उपयोग करने में सक्षम था। मैंने इससे एक आकर्षक धुन भी बजवाई। ?

फिर, मैं ब्लूटूथ स्कैनर ऐप्स में से एक का उपयोग करने लगा। मैंने सभी परिणामों को स्क्रॉल किया और बिंगो। वहां Tile था!

मैंने कुछ घंटे इंतजार किया और फिर से जांचा। मैं यह सुनिश्चित करना चाहता था कि यह थोड़ी देर बाद स्लीप मोड में न चला जाए। पता चला, यह हमेशा विज्ञापन करता है। जहां तक मैं बता सकता हूं, लगभग हर 8 सेकंड में।

इस सभी परीक्षण से एक निष्कर्ष निकला: इसका उपयोग प्रेजेंस डिटेक्शन के लिए आसानी से किया जा सकता है।

प्रक्रिया में अगला चरण यह पता लगाने की कोशिश करना था कि इसे Argon के साथ कैसे काम कराया जाए।

विज्ञापन

जैसा कि हमने पिछले चरण में एकत्र किया था, हम जानते हैं कि Tile लगभग हर 8 सेकंड में विज्ञापन कर रहा है। इसका मतलब है कि इसे Argon, Zenon या Boron सहित किसी भी डिवाइस का उपयोग करके आसानी से स्कैन किया जाना चाहिए।

इस उदाहरण के लिए मैं सुझाव देता हूं कि आप Argon का उपयोग करें। ऐसा इसलिए है क्योंकि ब्लूटूथ और मेश एक ही रेडियो साझा करते हैं। Tile को स्कैन करते समय, मेश से जुड़ा Xenon अक्सर विज्ञापन पैकेट को मिस कर देगा। इससे फाल्स नेगेटिव (और हताशा!) होगी।

इसी तर्ज पर, आप यह सुनिश्चित करना चाहेंगे कि आपका Argon किसी मेश नेटवर्क से जुड़ा नहीं है। आप CLI का उपयोग करके इसे हटा सकते हैं। अपने डिवाइस को अपने कंप्यूटर से कनेक्ट करें और निम्न कमांड चलाएं:

particle mesh remove <device name/ID> 

सुनिश्चित करें कि आप <device name/ID> को अपने डिवाइस के नाम या ID से बदल दें।

ठीक है, वापस अच्छी चीजों पर।

ब्लूटूथ में विज्ञापन के कुछ अलग उद्देश्य हो सकते हैं। आमतौर पर हालांकि, यह पेयरिंग चरण की शुरुआत को चिह्नित करता है। इस तरह अन्य डिवाइस जानते हैं कि विज्ञापन करने वाला डिवाइस उपलब्ध है।

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

उदाहरण के लिए, यहां Tile डिवाइस पर उपलब्ध सेवाओं का एक स्क्रीनशॉट है:

स्कैन करते समय हम दोबारा जांच करेंगे कि जिस डिवाइस से हम कनेक्ट हो रहे हैं उसमें सर्विस UUID 0xfeed है।

इससे पहले कि हम ब्लूटूथ की गहराई में जाएं, आइए Logger का उपयोग करके डिबगिंग के लिए अपना ऐप सेट करें।

लॉगिंग

इस ट्यूटोरियल में हम Logger का उपयोग करेंगे। यह आपको particle serial monitor का उपयोग करके अपने ऐप से लॉग संदेश प्रदर्शित करने की अनुमति देता है।

लॉगर के बारे में अच्छी विशेषताओं में से एक संदेश पदानुक्रम का विचार है। यह आपको, डिजाइनर को, उन संदेशों को चुनिंदा रूप से म्यूट करने की अनुमति देता है जो आवश्यक नहीं हो सकते हैं।

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

यहां logging.h में Particle के डिवाइस-ओएस रिपॉजिटरी में उपलब्ध लॉगिंग स्तर हैं:

// लॉग लेवल। सुनिश्चित करें कि नए जोड़े गए स्तरों के लिए log_level_name() अपडेट किया गया है typedef enum LogLevel { LOG_LEVEL_ALL = 1, // सभी संदेश लॉग करें LOG_LEVEL_TRACE = 1, LOG_LEVEL_INFO = 30, LOG_LEVEL_WARN = 40, LOG_LEVEL_ERROR = 50, LOG_LEVEL_PANIC = 60, LOG_LEVEL_NONE = 70, // कोई संदेश लॉग न करें // संगतता स्तर DEFAULT_LEVEL = 0, ALL_LEVEL = LOG_LEVEL_ALL, TRACE_LEVEL = LOG_LEVEL_TRACE, LOG_LEVEL = LOG_LEVEL_TRACE, // अप्रचलित DEBUG_LEVEL = LOG_LEVEL_TRACE, // अप्रचलित INFO_LEVEL = LOG_LEVEL_INFO, WARN_LEVEL = LOG_LEVEL_WARN, ERROR_LEVEL = LOG_LEVEL_ERROR, PANIC_LEVEL = LOG_LEVEL_PANIC, NO_LOG_LEVEL = LOG_LEVEL_NONE } LogLevel; 

कूल, लॉग लेवल। लेकिन हम उनका उपयोग कैसे करते हैं?

हम उन्हें इन फ़ंक्शंस को लागू करके उपयोग कर सकते हैं:

Log.trace, Log.info, Log.warn, Log.error।

उदाहरण के लिए:

Log.trace("This is a TRACE message."); 

यदि हम लॉग लेवल को LOG_LEVEL_INFO पर सेट करते हैं तो हम केवल Log.info, Log.warn, और Log.error से संदेश देखेंगे। LOG_LEVEL_WARN? केवल Log.warn और Log.error दिखाई देंगे। (उम्मीद है आपको आइडिया मिल गया।)

इसे सेट करने के लिए, हम डिफ़ॉल्ट लेवल को LOG_LEVEL_ERROR पर सेट करेंगे। हम ऐप-विशिष्ट LOG_LEVEL को LOG_LEVEL_TRACE पर भी सेट करेंगे। अंतिम परिणाम ऐसा दिखना चाहिए

// लॉगिंग के लिए SerialLogHandler logHandler(115200, LOG_LEVEL_ERROR, { { "app", LOG_LEVEL_TRACE }, // सभी ऐप संदेश सक्षम करें }); 

इस तरह हमें DeviceOS लॉग संदेशों से स्पैम नहीं मिलता। साथ ही, हमें ऐप से ही सभी लागू संदेश मिलते हैं।

वैसे, यदि आप अपने डिवाइस को एकल LOG_LEVEL पर सेट करना चाहते हैं तो आप इसे इस तरह सेट कर सकते हैं:

SerialLogHandler logHandler(LOG_LEVEL_INFO); 

जैसे-जैसे आप Particle के DeviceOS का उपयोग करके अपनी यात्रा जारी रखेंगे, आपको जल्द ही एहसास होगा कि यह कितना आसान हो सकता है। अब, चलिए अच्छी चीजों पर चलते हैं!

इसे सेट करना

पहले, हम यह सुनिश्चित करना चाहेंगे कि हम DeviceOS के सही वर्जन का उपयोग कर रहे हैं। 1.3 के बाद का कोई भी वर्जन ब्लूटूथ होगा। आप निर्देश यहां प्राप्त कर सकते हैं।

अगला हम Tile के लिए स्कैन करना शुरू करना चाहेंगे। हम इसे एक निर्दिष्ट अंतराल पर loop() फ़ंक्शन में करना चाहेंगे। हम इस मामले में millis() टाइमर का उपयोग करेंगे:

// डिवाइस के लिए स्कैन करें if( (millis() > lastSeen + TILE_RE_CHECK_MS) ){ BLE.scan(scanResultCallback, NULL); } 

सुनिश्चित करें कि आप फ़ाइल के शीर्ष पर lastSeen को इस तरह परिभाषित करते हैं:

system_tick_t lastSeen = 0; 

हम इसका उपयोग Tile को आखिरी बार "देखे" जाने का समय ट्रैक करने के लिए करेंगे। यानी आखिरी बार Argon ने Tile से विज्ञापन पैकेट देखा।

TILE_RE_CHECK_MS को इस तरह परिभाषित किया जा सकता है

#define TILE_RE_CHECK_MS 7500 

इस तरह हम कम से कम हर 7.5 सेकंड में विज्ञापन पैकेट की जांच कर रहे हैं।

Tile डिवाइस खोजने के लिए हम BLE.scan का उपयोग करेंगे। जब हम इसे कॉल करते हैं, तो यह स्कैनिंग प्रक्रिया शुरू करेगा। जैसे ही डिवाइस मिलते हैं scanResultCallback फायर होगा।

अभी के लिए, हम फ़ाइल के शीर्ष पर scanResultCallback को परिभाषित कर सकते हैं:

void scanResultCallback(const BleScanResult *scanResult, void *context) { } 

आप देखते हैं कि इसमें BleScanResult शामिल है। इसमें एड्रेस, RSSI और डिवाइस नाम (यदि उपलब्ध हो) और उपलब्ध सर्विस जानकारी होगी। यह बाद में हमारे Tile डिवाइस को खोजते समय काम आएगा!

याद रखें, कि BLE.scan तब तक वापस नहीं आता जब तक स्कैनिंग पूरी नहीं हो जाती। स्कैनिंग के लिए डिफ़ॉल्ट टाइमआउट 5 सेकंड है। आप BLE.setScanTimeout() का उपयोग करके उस मान को बदल सकते हैं। setScanTimeout 10ms इंक्रीमेंट में यूनिट लेता है। तो, 500ms टाइमआउट के लिए 50 का मान आवश्यक होगा।

इस ऐप के मामले में, मैं 8s (8000ms) के मान का उपयोग करने की सलाह दूंगा। आप इसे इस तरह सेट कर सकते हैं:

BLE.setScanTimeout(800); 

इस मामले में, डिवाइस तब तक स्कैन करेगा जब तक Tile को विज्ञापन करने में समय लगता है। इस तरह विज्ञापन पैकेट मिस होने की संभावना कम होती है।

स्कैन परिणाम संभालना

अब जब हमारे पास scanResultCallback है तो आइए परिभाषित करें कि अंदर क्या हो रहा है।

हम पहले विज्ञापन डेटा के अंदर सर्विस जानकारी प्राप्त करना चाहते हैं। सबसे अच्छा तरीका scanResult->advertisingData.serviceUUID का उपयोग करना है। हम UUID की एक सरणी पास करेंगे जिसे हमारे उपयोग के लिए कॉपी किया जाएगा।

BleUuid uuids[4]; int uuidsAvail = scanResult->advertisingData.serviceUUID(uuids,sizeof(uuids)/sizeof(BleUuid)); 

यह uuids को पॉप्युलेट करेगा ताकि आप उन पर पुनरावृति कर सकें। uuidsAvail उपलब्ध UUID की मात्रा के बराबर होगा।

हमारे मामले में हम एक विशेष UUID की तलाश कर रहे हैं। हम इसे फ़ाइल के शीर्ष पर परिभाषित करेंगे:

#define TILE_UUID 0xfeed 

आमतौर पर UUID बहुत लंबे होते हैं। इस तरह का एक छोटा UUID का मतलब है कि इसे आरक्षित किया गया है या यह ब्लूटूथ विनिर्देश का हिस्सा है। किसी भी मामले में हम उसी तरह इसकी जांच करेंगे जैसे हम 32bit या 128bit वर्जन की जांच करेंगे।

नैदानिक कारणों से हम डिवाइस जानकारी भी प्रिंट कर सकते हैं। इस मामले में RSSI और डिवाइस MAC एड्रेस उपयोगी हैं:

// मैक जानकारी प्रिंट करें BleAddress addr = scanResult->address; Log.trace("MAC: %02X:%02X:%02X:%02X:%02X:%02X", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]); Log.trace("RSSI: %dBm", scanResult->rssi); 

आखिरकार आइए एक लूप सेट करें यह देखने के लिए कि क्या मिले डिवाइस में UUID है:

// सभी उपलब्ध UUID पर लूप करें // Tile डिवाइस के लिए केवल एक होना चाहिए for(int i = 0; i < uuidsAvail; i++){ // हम जिस UUID को ढूंढ रहे हैं उसे प्रिंट करें if( uuids[i].shorted() == TILE_UUID ) { Log.trace("UUID: %x", uuids[i].shorted()); // स्कैनिंग बंद करें BLE.stopScanning(); return; } } 

हम UUID के "shorted" वर्जन की तुलना TILE_UUID से आसानी से कर सकते हैं। यह एक साधारण इंटीजर है इसलिए कोई जटिल मेमोरी तुलना ऑपरेशन आवश्यक नहीं हैं। तो, if( uuids[i].shorted() == TILE_UUID ) का उपयोग करना ठीक काम करता है।

आप नैदानिक जानकारी प्रिंट करने के लिए Log.trace का भी उपयोग कर सकते हैं। इस मामले में हम इसका उपयोग UUID के shorted() वर्जन को प्रिंट करने के लिए कर रहे हैं।

इसे टेस्ट करें!

आइए अब तक जो हमारे पास है उसे टेस्ट करें!

ऐप को अपने Argon पर प्रोग्राम करें। टर्मिनल खोलें और डिबग संदेश देखने के लिए particle serial monitor चलाएं। यहां एक उदाहरण है जो आप देख सकते हैं:

0000005825 [app] TRACE: MAC: 65:C7:B3:AF:73:5C 0000005827 [app] TRACE: RSSI: -37Bm 0000005954 [app] TRACE: MAC: B3:D9:F1:F0:5D:7E 0000005955 [app] TRACE: RSSI: -62Bm 0000006069 [app] TRACE: MAC: C5:F0:74:3D:13:77 0000006071 [app] TRACE: RSSI: -62Bm 0000006217 [app] TRACE: MAC: 65:C7:B3:AF:73:5C 0000006219 [app] TRACE: RSSI: -39Bm 0000006224 [app] TRACE: MAC: B3:D9:F1:F0:5D:7E 0000006225 [app] TRACE: RSSI: -62Bm 0000006296 [app] TRACE: MAC: D7:E7:FE:0C:A5:C0 0000006298 [app] TRACE: RSSI: -60Bm 0000006299 [app] TRACE: UUID: feed 

ध्यान दें कि संदेश में TRACE और [app] शामिल हैं? इसका मतलब है कि यह एप्लिकेशन कोड से उत्पन्न एक ट्रेस संदेश है। आसान है ना?

यह कोड जल्दी स्पैमी हो जाता है, खासकर यदि आप बहुत सारे विज्ञापन ब्लूटूथ डिवाइस वाले वातावरण में हैं। यदि आपका Tile चालू है और चल रहा है तो अंततः आपको UUID: feed वाला एक संदेश दिखाई देगा। इसका मतलब है कि आपका Argon Tile मिल गया!

अगला हम ऑनबोर्ड मोड बटन का उपयोग करके Tile के एड्रेस को मेमोरी में "प्रोग्राम" करेंगे। इस तरह हम उन सभी डिवाइस को फ़िल्टर कर सकते हैं जिनकी हमें परवाह नहीं है।

बटन दबाने पर डिवाइस जोड़ें

पहले हमें यह पता लगाने की जरूरत है कि मोड बटन को कैसे मॉनिटर किया जाए। डॉक्यूमेंटेशन के अनुसार सबसे अच्छा तरीका System.on का उपयोग करना है।

System.on(button_click, eventHandler); 

पहला तर्क सिस्टम इवेंट का नाम है। हमारे मामले में यह button_click है। दूसरा तर्क एक इवेंट हैंडलर फ़ंक्शन है। हम इसे अभी के लिए eventHandler कहेंगे।

अब आइए eventHandler बनाएं

void eventHandler(system_event_t event, int duration, void* ) { } 

महत्वपूर्ण: आप eventHandler के अंदर Log फ़ंक्शन का उपयोग नहीं कर सकते। इसे टेस्ट करने का एक आसान तरीका D7 पर LED को टॉगल करना है। आइए इसे सेट करें!

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

// LED पिन सेट करें pinMode(D7,OUTPUT); 

फिर हम इसे eventHandler के अंदर जोड़ सकते हैं

if( event == button_click ) { if( digitalRead(D7) ) { digitalWrite(D7,LOW); } else { digitalWrite(D7,HIGH); } } 

हम तब D7 (ऑनबोर्ड नीली LED) पर लिख सकते हैं। हम digitalRead का उपयोग करके LED की स्थिति भी पढ़ सकते हैं। यह स्थिति के आधार पर HIGH या LOW के साथ प्रतिक्रिया देगा।

फर्मवेयर को डिवाइस पर लोड करें और हमारे पास नीली LED पर अच्छा नियंत्रण होगा!

अगले खंड में, हम डिवाइस को "लर्निंग" मोड में डालने के लिए मोड बटन का उपयोग करेंगे। यह हमें टारगेट Tile डिवाइस के साथ वन-टच सेटअप करने की अनुमति देगा।

एड्रेस को EEPROM में स्टोर करना

इस अगले चरण में हम Tile के एड्रेस को EEPROM में स्टोर करेंगे। इस तरह जब डिवाइस रीस्टार्ट होता है या पावर खो देता है तो हम बाद में Tile की पहचान कर पाएंगे।

एक सवाल अभी भी बाकी है। हम इसे पहली बार में एड्रेस सेव करने के लिए कैसे प्राप्त करते हैं?

बटन प्रेस को मॉनिटर करके, हम डिवाइस को "लर्निंग" मोड में डाल सकते हैं। डिवाइस Tile के लिए स्कैन करेगा, और यदि यह एक ढूंढता है तो एड्रेस सेव करेगा।

पहले if( uuids[i].shorted() == TILE_UUID ) के भीतर एक कंडीशनल जोड़ें:

// अगर हम लर्निंग मोड में हैं। EEPROM में सेव करें if( isLearningModeOn() ) { searchAddress = scanResult->address; EEPROM.put(TILE_EEPROM_ADDRESS, searchAddress); setLearningModeOff(); } 

हम D7 की स्थिति का उपयोग यह जानने के तरीके के रूप में करेंगे कि हम "लर्निंग मोड" में हैं। हम digitalRead(D7) का उपयोग करके D7 को पढ़कर ऐसा करते हैं। आइए एक फ़ंक्शन बनाएं जो इसे और स्पष्ट करे:

bool isLearningModeOn() { return (digitalRead(D7) == HIGH); } 

हम digitalWrite(D7,LOW); और digitalWrite(D7,HIGH); को समान फ़ंक्शंस से भी बदल सकते हैं। इस तरह यह अधिक सीधा है कि हम क्या कर रहे हैं।

// "लर्निंग मोड" ऑन सेट करें void setLearningModeOn() { digitalWrite(D7,HIGH); } // "लर्निंग मोड" ऑफ सेट करें void setLearningModeOff() { digitalWrite(D7,LOW); } 

फिर, हम ग्लोबल वेरिएबल searchAddress को स्कैन परिणाम के रूप में असाइन करते हैं। हम searchAddress को फ़ाइल के शीर्ष पर इस तरह सेट करते हैं:

BleAddress searchAddress; 

अगला हम इसे EEPROM.put का उपयोग करके नॉन-वोलेटाइल मेमोरी में सेव करना चाहते हैं। TILE_EEPROM_ADDRESS को 0xa के रूप में परिभाषित किया गया है। आप TILE_EEPROM_ADDRESS को परिभाषित कर सकते हैं जो भी मेमोरी एड्रेस आपकी पसंद का हो। यहां फ़ाइल के शीर्ष पर रखी गई पूरी परिभाषा है।

#define TILE_EEPROM_ADDRESS 0xa 

अंत में, हम setLearningModeOff() का उपयोग करके LED और "लर्निंग मोड" को बंद कर देते हैं

हर बार जब कोई डिवाइस मिलता है तो हम millis() का उपयोग करके lastSeen सेट करेंगे। इसके अलावा, हम lastRSSI का उपयोग करके अंतिम RSSI को ट्रैक कर सकते हैं। यह डिवाइस कितना करीब है यह जानने का एक सस्ता तरीका है। हम यह जानकारी प्राप्त करने के लिए scanResult->rssi का उपयोग करेंगे और इसे lastRSSI वेरिएबल पर सेट करेंगे।

कुल मिलाकर, आपके परिवर्तन कुछ इस तरह दिखने चाहिए:

... // हम जिस UUID को ढूंढ रहे हैं उसे प्रिंट करें if( uuids[i].shorted() == TILE_UUID ) { Log.trace("UUID: %x", uuids[i].shorted()); // अगर हम लर्निंग मोड में हैं। EEPROM में सेव करें if( isLearningModeOn() ) { searchAddress = scanResult->address; EEPROM.put(TILE_EEPROM_ADDRESS, searchAddress); setLearningModeOff(); } // जानकारी सेव करें lastSeen = millis(); lastRSSI = scanResult->rssi; // स्कैनिंग बंद करें BLE.stopScanning(); return; } 

इस फ़ंक्शन से पहले, हम उन डिवाइस को फ़िल्टर कर सकते हैं जो हमारे searchAddress से मेल नहीं खाते। if( uuids[i].shorted() == TILE_UUID ) से पहले निम्नलिखित जोड़ें:

// अगर डिवाइस एड्रेस मेल नहीं खाता या हम "लर्निंग मोड" में नहीं हैं if( !(searchAddress == scanResult->address) && !isLearningModeOn() ) { return; } 

यह उन डिवाइस को छोड़ देगा जो मेल नहीं खाते। यह केवल तभी आगे बढ़ेगा जब एड्रेस मेल खाता हो या हम "लर्निंग मोड" में हों।

अब, हमारे लिए स्टार्टअप पर searchAddress लोड करने के लिए, हमें इसे फ्लैश से लोड करना होगा। इस लाइन को अपने setup(): में जोड़ें

EEPROM.get(TILE_EEPROM_ADDRESS, searchAddress); 

फिर, यह सुनिश्चित करने के लिए जांचें कि एड्रेस वैध है। यह वैध नहीं होगा यदि सभी बाइट्स 0xFF हैं:

// एड्रेस के बारे में चेतावनी if( searchAddress == BleAddress("ff:ff:ff:ff:ff:ff") ) { Log.warn("इस बोर्ड को लर्निंग मोड में रखें"); Log.warn("और अपने Tile को पास रखें।"); } 

हमें अपने Argon को अपने Tile का एड्रेस "सिखाने" में सक्षम होना चाहिए। आइए इसे टेस्ट करें!

इसे टेस्ट करें।

अब अगर हम ऐप को कंपाइल और चलाते हैं, तो ध्यान दें कि अब कोई लॉग आउटपुट नहीं है? हमें Tile एड्रेस को Particle डिवाइस को "सिखाना" होगा। तो, मोड बटन दबाएं। नीली LED चालू होनी चाहिए।

एक बार जब आपका Tile मिल जाता है तो LED बंद हो जाएगी और आपको कमांड लाइन पर कुछ आउटपुट दिखाई देगा। जो हमने पहले देखा था उसके समान:

0000006296 [app] TRACE: MAC: D7:E7:FE:0C:A5:C0 0000006298 [app] TRACE: RSSI: -60Bm 0000006299 [app] TRACE: UUID: feed 

डिवाइस को मेमोरी में कमिट कर दिया गया है!

आप रीसेट बटन दबाकर और ऊपर जैसा ही आउटपुट चेक करके यह भी जांच सकते हैं कि रीसेट के बाद यह अभी भी सेव है या नहीं। अगर यह दिखाई दे रहा है, तो हम अभी भी अच्छे हैं!

क्लाउड अपडेट करें

अंत में आइए checkTileStateChanged नामक एक फ़ंक्शन सेट करें। हम इसका उपयोग नियमित अंतराल पर Tile की स्थिति में परिवर्तनों की जांच के लिए करेंगे।

bool checkTileStateChanged( TilePresenceType *presence ) { } 

इस फ़ंक्शन का मुख्य उद्देश्य lastSeen वेरिएबल की तुलना "टाइमआउट" अवधि से करना है। हमारे मामले में, हमारी टाइमआउट अवधि TILE_NOT_HERE_MS है जिसे सेट किया जाना चाहिए

#define TILE_NOT_HERE_MS 30000 

आपके प्रोग्राम के शीर्ष के पास। दो और शर्तें भी हैं जिन पर ध्यान देना है। एक जहां lastSeen 0 के बराबर है। यह आमतौर पर इसलिए होता है क्योंकि ऐप ने स्टार्टअप के बाद अभी तक Tile नहीं ढूंढा है।

अंतिम मामला वह होगा जब डिवाइस देखा गया हो और lastSeen 0 नहीं है। तो checkTileStateChanged के भीतर आइए सब कुछ एक साथ रखें।

// जांचें कि क्या यह यहां है। if( millis() > lastSeen+TILE_NOT_HERE_MS ) { } else if ( lastSeen == 0 ) { } else { } return false; 

अब हम केवल इस फ़ंक्शन को true वापस करना चाहते हैं यदि स्थिति बदल गई है। तो हमें TilePresenceType पॉइंटर का लाभ उठाने की आवश्यकता होगी।

TilePresenceType केवल सभी संभावित स्थितियों का एक गणना है। आप इसे अपने फ़ाइल के शीर्ष पर भी रख सकते हैं। यहां यह है:

typedef enum { PresenceUnknown, Here, NotHere } TilePresenceType; 

आपको एक ग्लोबल वेरिएबल की भी आवश्यकता होगी जिसे हम फ़ंक्शन में पास कर सकें। इसे अपने फ़ाइल के शीर्ष पर भी सेट करें:

// डिफ़ॉल्ट स्थिति TilePresenceType present = PresenceUnknown; 

अब, हम प्रत्येक चरण में तुलना कर सकते हैं। क्या यह मानदंडों को पूरा करता है? क्या स्थिति पिछली से अलग है? यदि हां, तो true वापस करें।

याद रखें, हम presence को नए अपडेटेड मान पर सेट करना चाहेंगे। तो प्रत्येक कंडीशन को presence मान अपडेट करना चाहिए। उदाहरण के लिए:

*presence = NotHere; 

यहां पूरी तरह से विकसित फ़ंक्शन कैसा दिखता है:

bool checkTileStateChanged( TilePresenceType *presence ) { // जांचें कि क्या यह यहां है। if( millis() > lastSeen+TILE_NOT_HERE_MS ) { if( *presence != NotHere ) { *presence = NotHere; Log.trace("not here!"); return true; } // केस अगर हमने अभी शुरू किया है } else if ( lastSeen == 0 ) { if( *presence != PresenceUnknown ) { *presence = PresenceUnknown; Log.trace("unknown!"); return true; } // केस अगर lastSeen < TILE_NOT_HERE_MS } else { if( *presence != Here ) { *presence = Here; Log.trace("here!"); return true; } } return false; } 

अब हम इस फ़ंक्शन का उपयोग मेन लूप में Ble.scan() शुरू करने के टाइमर के नीचे कर सकते हैं। हम इसका उपयोग JSON पेलोड भेजने के लिए कर सकते हैं। इस मामले में हम ब्लूटूथ एड्रेस, lastSeen डेटा, lastRSSI डेटा और एक संदेश जैसी महत्वपूर्ण जानकारी शामिल करेंगे।

// अगर हमारे पास कोई बदलाव है if( checkTileStateChanged(&present) ) { } 

हम अपने एड्रेस को स्ट्रिंग फॉर्मेट में प्राप्त करने के लिए char की एक सरणी का उपयोग करेंगे। आप toString() को toCharArray के साथ चेन कर सकते हैं ताकि हमें जो चाहिए वह मिल जाए।

// एड्रेस स्ट्रिंग प्राप्त करें char address[18]; searchAddress.toString().toCharArray(address,sizeof(address)); 

एक उदाहरण पेलोड स्ट्रिंग इस तरह दिख सकती है:

// पेलोड बनाएं status = String::format("{\"address\":\"%s\",\"lastSeen\":%d,\"lastRSSI\":%i,\"status\":\"%s\"}", address, lastSeen, lastRSSI, messages[present]); 

status बस फ़ाइल के शीर्ष पर परिभाषित एक String है:

// क्लाउड पर जाने वाला पेलोड String status; 

आप देखते हैं कि messages नामक एक वेरिएबल भी है। यह स्ट्रिंग्स की एक स्थिर कॉन्स्ट सरणी है। वे TilePresenceType के मूल्यों से मैप किए गए हैं। यहां यह कैसा दिखता है

const char * messages[] { "unknown", "here", "not here" }; 

ताकि PresenceUnknown "unknown" से मेल खाता है, Here "here" से मेल खाता है, आदि। एनम के साथ स्ट्रिंग को जोड़ने का यह एक सस्ता आसान तरीका है।

अंत में हम पब्लिश और प्रोसेस करेंगे। यह हमें अपडेट को तुरंत भेजने की अनुमति देता है।

// RSSI और डिवाइस जानकारी पब्लिश करें Particle.publish("status", status, PRIVATE, WITH_ACK); // पब्लिश इवेंट को तुरंत प्रोसेस करें Particle.process(); 

समग्र फ़ंक्शन अंत में कुछ इस तरह दिखना चाहिए:

// अगर हमारे पास कोई बदलाव है if( checkTileStateChanged(&present) ) { // एड्रेस स्ट्रिंग प्राप्त करें char address[18]; searchAddress.toString().toCharArray(address,sizeof(address)); // पेलोड बनाएं status = String::format("{\"address\":\"%s\",\"lastSeen\":%d,\"lastRSSI\":%i,\"status\":\"%s\"}", address, lastSeen, lastRSSI, messages[present]); // RSSI और डिवाइस जानकारी पब्लिश करें Particle.publish("status", status, PRIVATE, WITH_ACK); // पब्लिश इवेंट को तुरंत प्रोसेस करें Particle.process(); } 

अब, आइए इसे टेस्ट करें!

इसे टेस्ट करना!

हम यह टेस्ट कर सकते हैं कि हमारे पब्लिश इवेंट Particle Workbench छोड़े बिना हो रहे हैं। View → Terminal. पर जाकर एक नया टर्मिनल खोलें। फिर निम्न कमांड का उपयोग करें:

particle subscribe --device <device_name> <event_name> 

<device_name> को अपने डिवाइस के नाम या ID से बदलें।

<event_name> को इवेंट के नाम से बदलें। हमारे मामले में यह status है।

फिर आप बैटरी हटाकर और "not here" अलर्ट की प्रतीक्षा करके यह सब टेस्ट कर सकते हैं। बैटरी वापस लगाएं और आपको "here" अलर्ट मिलना चाहिए।

आउटपुट का एक उदाहरण यहां दिया गया है

> particle subscribe --device hamster_turkey status Subscribing to "status" from hamster_turkey's stream Listening to: /v1/devices/hamster_turkey/events/status {"name":"status","data":"{\"address\":\"C0:A5:0C:FE:E7:D7\",\"lastSeen\":40154002,\"lastRSSI\":-82,\"status\":\"not here\"}","ttl":60,"published_at":"2019-09-07T02:29:42.232Z","coreid":"e00fce68d36c42ef433428eb"} {"name":"status","data":"{\"address\":\"C0:A5:0C:FE:E7:D7\",\"lastSeen\":40193547,\"lastRSSI\":-83,\"status\":\"here\"}","ttl":60,"published_at":"2019-09-07T02:29:50.352Z","coreid":"e00fce68d36c42ef433428eb"} 

वेबहुक कॉन्फिगर करना

इस ट्यूटोरियल के अंतिम भाग में हम वेबहुक का उपयोग करके पुश नोटिफिकेशन सेट करेंगे। जैसा कि पहले उल्लेख किया गया है, हम Pushover और उनके आसान API का उपयोग करके आपकी पसंद के डिवाइस पर पुश नोटिफिकेशन भेजेंगे।

Pushover का उपयोग करने के लिए एक शानदार आसान API है। उनका एप्लिकेशन उन स्थितियों के लिए एक स्विस आर्मी नाइफ है जहां आप पुश नोटिफिकेशन भेजने के लिए ऐप कोड नहीं करना चाहते।

पहली चीज जिस पर आपको ध्यान देना होगा वह है आपका यूजर की। आप Pushover में लॉग इन करके इसे प्राप्त कर सकते हैं। नोट: यदि आपने पहले से नहीं किया है तो आपको पहले एक खाता सेट करना होगा।

यह कुछ इस तरह दिखना चाहिए:

यदि आप लॉग इन हैं और यह पेज नहीं देखते हैं, तो Pushover लोगो पर क्लिक करें और यह आपको वापस लाना चाहिए।

अगला हम एक एप्लिकेशन बनाना चाहेंगे। स्क्रीन के शीर्ष पर Apps & Plugins पर क्लिक करें।

फिर आपको Create a New Application. पर क्लिक करना चाहिए। यह हमें API टोकन प्राप्त करने की अनुमति देगा जिसकी Particle वेबहुक सेटअप में आवश्यकता होगी।

अपनी इच्छानुसार नाम सेट करें। यदि आप रिमाइंडर चाहते हैं तो विवरण भरें। बॉक्स पर क्लिक करें और फिर Create Application. पर क्लिक करें।

आपको अगले पेज पर जाना चाहिए। API टोकन/की कॉपी करें और सेव करें हमें इसकी भी कुछ चरणों में आवश्यकता होगी।

अब, आइए वेबहुक सेट करें। https://console.particle.io पर जाएं और एक नया इंटीग्रेशन बनाएं।

हम इवेंट नाम को status पर सेट करेंगे।

URL को https://api.pushover.net/1/messages.json पर सेट करें

साथ ही, यदि आप किसी विशिष्ट डिवाइस द्वारा फ़िल्टर करना चाहते हैं तो सुनिश्चित करें कि आप इसे डिवाइस ड्रॉपडाउन में चुनते हैं।

उन्नत सेटिंग्स के तहत हम कुछ फ़ील्ड सेट करके समाप्त करेंगे।

निम्नलिखित फ़ील्ड बनाएं: token, user, title, और message। फिर token को पहले प्राप्त API टोकन पर सेट करें। यूजर की के लिए भी ऐसा ही करें।

title आपके संदेश के शीर्षक के रूप में दिखाई देगा। इसे जो भी आपके लिए समझ में आए वैसा बनाएं।

आप message को The Tile is currently {{{status}}}. RSSI: {{{lastRSSI}}} के रूप में सेट कर सकते हैं।

हम यहां मस्टैश टेम्पलेट्स का उपयोग कर रहे हैं। वे आपको पब्लिश किए गए पेलोड में डेटा का उपयोग करने और इसे अपनी पसंद के अनुसार पुनः फॉर्मेट करने की अनुमति देते हैं। हमारे मामले में, हम उनका उपयोग "रिक्त स्थान भरने" के लिए कर रहे हैं। प्रोसेस होने के बाद message कुछ इस तरह दिखेगा:

The Tile is currently here. RSSI: -77

एक साइड नोट के रूप में, मैं इन टेम्पलेट्स के बारे में अपने गाइड में अधिक बात करूंगा। उसके लिए बने रहें!

इसे टेस्ट करें

एक बार आपका इंटीग्रेशन हो जाने के बाद, आप पहले के चरण में हमने जो किया था वही करके टेस्ट कर सकते हैं। बैटरी हटाएं, और "not here" संदेश की प्रतीक्षा करें। इसे वापस लगाएं और "here" संदेश की प्रतीक्षा करें।

यह iPhone पर ऐसा दिखेगा:

जैसा कि आप देख सकते हैं, मैंने इसका एक गुच्छा टेस्ट किया! ?

यदि आप यहां तक पहुंच गए हैं और सब कुछ काम कर रहा है, तो शानदार काम। अब आपके पास अपने घर, कार्यालय या जहां भी के लिए एक Tile ट्रैकर है।

कोड

इस उदाहरण के लिए तैयार कोड ढूंढ रहे हैं? मैं भी होता! यह GitHub पर होस्ट किया गया है और यहां उपलब्ध है।

निष्कर्ष

जैसा कि आप कल्पना कर सकते हैं, इस लेख में उपयोग की गई तकनीकों और प्रौद्योगिकियों का उपयोग कई तरीकों से किया जा सकता है। आइए कुछ प्रमुख निष्कर्षों को सारांशित करें:

1. ऑफ-द-शेल्फ Tile डिवाइस को स्कैन करने और पहचानने के लिए ब्लूटूथ सेंट्रल का उपयोग करना
2. Tile पहचान जानकारी को EEPROM में स्टोर करना। इस तरह इसे स्टार्टअप पर पुनः प्राप्त किया जा सकता है।
3. क्लाउड पर अपडेट पुश करने के लिए हमारे परिचित Particle.publish का उपयोग करना।
4. स्टेट चेंज पर पुश नोटिफिकेशन बनाने के लिए Particle इंटीग्रेशन वेबहुक का उपयोग करना।

अब जब आपके पास यह सब काम कर रहा है, तो इस पर विस्तार करें, इसे हैक करें और इसे अपना बनाएं। ओह और शेयर करना न भूलें! मुझे आपसे सुनना अच्छा लगेगा। hello@jaredwolff.com

यह पोस्ट पसंद आया? नीचे दिए गए शेयर लिंक में से किसी एक पर क्लिक करें और इसे दुनिया के साथ शेयर करें। :)

यह मेरे ब्लॉग से एक क्रॉस पोस्ट है। आप मूल को यहां देख सकते हैं।

और सीखने में रुचि है? मैं Particle प्लेटफॉर्म का अधिकतम लाभ कैसे उठाया जाए, इस पर एक गाइड लिख रहा हूं। इसके बारे में यहां और जानें।