अंतिम कैसे करें:20 मिनट में हार्डवेयर के साथ एक ब्लूटूथ स्विफ्ट ऐप बनाएं

पिछले ट्यूटोरियल में, आपने सीखा कि कण क्सीनन एप्लिकेशन में ब्लूटूथ कैसे जोड़ा जाता है। इस तरह आप एनआरएफ कनेक्ट या लाइट ब्लू एक्सप्लोरर जैसे परीक्षण ऐप से ऑनबोर्ड आरजीबी एलईडी को नियंत्रित कर सकते हैं।

इस पोस्ट में, हम इसे एक कदम आगे ले जाने जा रहे हैं। हम पार्टिकल मेश RGB एलईडी को नियंत्रित करने के लिए एक स्विफ्ट ऐप विकसित करने जा रहे हैं। यदि सब कुछ ठीक रहा, तो आपके पास लगभग 20 मिनट में एक कार्यशील ऐप होना चाहिए!

आइए शुरू करें।

पूरा लेख पढ़ने के लिए अभी समय नहीं है?

पीडीएफ संस्करण यहां डाउनलोड करें।

सेट अप करना

• एक्सकोड इंस्टॉल करें। आप इसे यहां ऐप स्टोर से डाउनलोड कर सकते हैं।
• आपको Apple लॉगिन की भी आवश्यकता होगी। मैं अपने iCloud ईमेल का उपयोग करता हूं। यदि आपके पास अभी तक Xcode में नया खाता नहीं है तो आप एक नया खाता बना सकते हैं।
• कण जाल बोर्ड पर RGB उदाहरण कोड स्थापित करें।

प्रोजेक्ट बनाएं

एक बार सब कुछ स्थापित हो जाने के बाद, चलिए मज़ेदार चीज़ों पर चलते हैं!

Xcode खोलें और फ़ाइल → नई परियोजना पर जाएं

सिंगल व्यू ऐप चुनें।

फिर प्रोजेक्ट का नाम अपडेट करें अपनी पसंद का होना। मैंने अपने संगठन के पहचानकर्ता को भी com.jaredwolff . में बदल दिया है . जैसा आप ठीक समझें इसे संशोधित करें!

इसे सहेजने के लिए किसी स्थान का चयन करें।

इसके बाद अपनी Info.plist. खोजें

अपडेट करें info.plist Privacy - Bluetooth Peripheral Usage Description . जोड़कर

मैंने जिस विवरण का उपयोग किया वह App uses Bluetooth to connect to the Particle Xenon RGB Example . था

यदि आप कभी भी इसे जारी करना चाहते हैं तो यह आपको अपने ऐप में ब्लूटूथ का उपयोग करने की अनुमति देता है।

अब, सब कुछ न्यूनतम रूप से कार्यात्मक हो जाए!

न्यूनतम रूप से कार्यात्मक

इसके बाद, हम कनेक्ट करने और सेवाओं की खोज करने के लिए एक न्यूनतम कार्यात्मक ऐप प्राप्त करेंगे। अधिकांश कार्रवाई ViewController.swift . में होगी ।

आइए पहले आयात करें CoreBluetooth

    import CoreBluetooth

यह हमें आईओएस में ब्लूटूथ कम ऊर्जा कार्यक्षमता को नियंत्रित करने की अनुमति देता है। तो चलिए दोनों को जोड़ते हैं CBPeripheralDelegate और CBCentralManagerDelegate करने के लिए ViewController कक्षा।

    class ViewController: UIViewController, CBPeripheralDelegate, CBCentralManagerDelegate {

आइए अब वास्तविक केंद्रीय प्रबंधक और परिधीय को स्टोर करने के लिए स्थानीय निजी चर बनाएं। हम उन्हें और क्षण भर के लिए सेट कर देंगे।

    // Properties
    private var centralManager: CBCentralManager!
    private var peripheral: CBPeripheral!

आपके viewDidLoad . में फ़ंक्शन, आइए centralManager . में प्रवेश करें

    centralManager = CBCentralManager(delegate: self, queue: nil)

सेटिंग delegate: self महत्वपूर्ण है। अन्यथा स्टार्टअप पर केंद्रीय राज्य कभी नहीं बदलता है।

इससे पहले कि हम आगे बढ़ें, एक अलग फ़ाइल बनाते हैं और उसे ParticlePeripheral.swift कहते हैं . इसे कहीं भी रखा जा सकता है लेकिन मैंने इसे मॉडल . नामक एक अलग 'समूह' में रखा है बाद के लिए।

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

    import UIKit
    import CoreBluetooth

    class ParticlePeripheral: NSObject {

        /// MARK: - Particle LED services and charcteristics Identifiers

        public static let particleLEDServiceUUID     = CBUUID.init(string: "b4250400-fb4b-4746-b2b0-93f0e61122c6")
        public static let redLEDCharacteristicUUID   = CBUUID.init(string: "b4250401-fb4b-4746-b2b0-93f0e61122c6")
        public static let greenLEDCharacteristicUUID = CBUUID.init(string: "b4250402-fb4b-4746-b2b0-93f0e61122c6")
        public static let blueLEDCharacteristicUUID  = CBUUID.init(string: "b4250403-fb4b-4746-b2b0-93f0e61122c6")

    }

ViewController.swift में वापस जाएं आइए ब्लूटूथ बिट्स को एक साथ जोड़ते हैं।

ब्लूटूथ बिट्स

ब्लूटूथ के साथ करने के लिए सब कुछ घटना आधारित है। हम इन घटनाओं को संभालने वाले कई कार्यों को परिभाषित करेंगे। यहाँ महत्वपूर्ण हैं:

centralManagerDidUpdateState ब्लूटूथ पेरिफेरल के चालू या बंद होने पर अपडेट होता है। जब कोई ऐप पहली बार शुरू होता है तो यह आग लग जाएगा ताकि आप ब्लूटूथ की स्थिति जान सकें। हम यहां स्कैन करना भी शुरू करते हैं।

centralManager didDiscover घटना तब होती है जब आप स्कैन परिणाम प्राप्त करते हैं। हम इसका उपयोग कनेक्शन शुरू करने के लिए करेंगे।

centralManager didConnect डिवाइस कनेक्ट होने के बाद ईवेंट सक्रिय हो जाता है। हम यहां डिवाइस की खोज शुरू करेंगे। नोट: डिवाइस की खोज वह तरीका है जिससे हम यह निर्धारित करते हैं कि कौन सी सेवाएं और विशेषताएं उपलब्ध हैं। यह पुष्टि करने का एक अच्छा तरीका है कि हम किस प्रकार के डिवाइस से जुड़े हैं।

peripheral didDiscoverServices एक बार सभी सेवाओं की खोज हो जाने के बाद पहली घटना। ध्यान दें कि हमने centralManager . से स्विच किया है करने के लिए peripheral अब जब हम जुड़े हुए हैं। हम यहां विशेषता खोज शुरू करेंगे। हम लक्ष्य के रूप में RGB सेवा UUID का उपयोग करेंगे।

peripheral didDiscoverCharacteristicsFor घटना प्रदान की गई सेवा यूयूआईडी का उपयोग करके सभी विशेषताओं को प्रदान करेगी। यह पूर्ण उपकरण खोज करने की श्रृंखला का अंतिम चरण है। यह बालों वाली है लेकिन इसे केवल एक बार कनेक्शन चरण के दौरान किया जाना है!

सभी ब्लूटूथ फ़ंक्शन को परिभाषित करना।

अब जब हम जानते हैं कि ट्रिगर होने वाले फंक्शन इवेंट क्या हैं। हम उन्हें तार्किक क्रम में परिभाषित करेंगे कि वे एक कनेक्शन चक्र के दौरान होते हैं।

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

    // If we're powered on, start scanning
        func centralManagerDidUpdateState(_ central: CBCentralManager) {
            print("Central state update")
            if central.state != .poweredOn {
                print("Central is not powered on")
            } else {
                print("Central scanning for", ParticlePeripheral.particleLEDServiceUUID);
                centralManager.scanForPeripherals(withServices: [ParticlePeripheral.particleLEDServiceUUID],
                                                  options: [CBCentralManagerScanOptionAllowDuplicatesKey : true])
            }
        }

centralManager को परिभाषित करना didDiscover प्रक्रिया में हमारा अगला कदम है। हम जानते हैं कि अगर यह घटना हुई है तो हमें एक उपकरण मिल गया है।

    // Handles the result of the scan
        func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {

            // We've found it so stop scan
            self.centralManager.stopScan()

            // Copy the peripheral instance
            self.peripheral = peripheral
            self.peripheral.delegate = self

            // Connect!
            self.centralManager.connect(self.peripheral, options: nil)

        }

इसलिए, हम self.centralManager.stopScan() . का उपयोग करके स्कैन करना बंद कर देते हैं . हमने peripheral . सेट किया है तो यह ऐप के माध्यम से बनी रहती है। फिर हम self.centralManager.connect . का उपयोग करके उस डिवाइस से कनेक्ट होते हैं

एक बार कनेक्ट होने के बाद, हमें दोबारा जांच करनी होगी कि क्या हम सही डिवाइस के साथ काम कर रहे हैं।

    // The handler if we do connect succesfully
        func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
            if peripheral == self.peripheral {
                print("Connected to your Particle Board")
                peripheral.discoverServices([ParticlePeripheral.particleLEDServiceUUID])
            }
        }

दो बाह्य उपकरणों की तुलना करके हम इसके उस उपकरण को जानेंगे जो हमने पहले पाया था। हम peripheral.discoverService . का उपयोग करके सेवाओं की खोज शुरू करेंगे . हम ParticlePeripheral.particleLEDServiceUUID . का उपयोग कर सकते हैं एक पैरामीटर के रूप में। इस तरह हम ऐसी कोई भी सेवा नहीं लेते हैं जिसकी हमें परवाह नहीं है।

एक बार जब हम खोज सेवाएं समाप्त कर लेते हैं, तो हमें एक didDiscoverServices मिलेगा प्रतिस्पर्धा। हम सभी "उपलब्ध" सेवाओं के माध्यम से पुनरावृति करते हैं। (हालांकि केवल एक ही होगा!)

    // Handles discovery event
        func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
            if let services = peripheral.services {
                for service in services {
                    if service.uuid == ParticlePeripheral.particleLEDServiceUUID {
                        print("LED service found")
                        //Now kick off discovery of characteristics
                        peripheral.discoverCharacteristics([ParticlePeripheral.redLEDCharacteristicUUID,
                                                                 ParticlePeripheral.greenLEDCharacteristicUUID,
                                                                 ParticlePeripheral.blueLEDCharacteristicUUID], for: service)
                        return
                    }
                }
            }
        }

इस बिंदु तक यह तीसरी बार है जब हम यह सुनिश्चित करने के लिए जाँच कर रहे हैं कि हमारे पास सही सेवा है। यह बाद में अधिक उपयोगी हो जाता है जब कई विशेषताएं और कई सेवाएं होती हैं।

हम peripheral.discoverCharacteristics . पर कॉल करते हैं हम जिन विशेषताओं की तलाश कर रहे हैं, उनके लिए UUIDs की एक सरणी के साथ। वे सभी यूयूआईडी हैं जिन्हें हमने ParticlePeripheral.swift . में परिभाषित किया है ।

अंत में, हम didDiscoverCharacteriscsFor . को संभालते हैं प्रतिस्पर्धा। हम सभी उपलब्ध विशेषताओं के माध्यम से पुनरावृति करते हैं। जैसे-जैसे हम पुनरावृति करते हैं हम उन लोगों से तुलना करते हैं जिनकी हम तलाश कर रहे हैं।

    // Handling discovery of characteristics
        func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
            if let characteristics = service.characteristics {
                for characteristic in characteristics {
                    if characteristic.uuid == ParticlePeripheral.redLEDCharacteristicUUID {
                        print("Red LED characteristic found")
                    } else if characteristic.uuid == ParticlePeripheral.greenLEDCharacteristicUUID {
                        print("Green LED characteristic found")
                    } else if characteristic.uuid == ParticlePeripheral.blueLEDCharacteristicUUID {
                        print("Blue LED characteristic found");
                    }
                }
            }
        }

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

हमारे न्यूनतम उदाहरण का परीक्षण करना

इससे पहले कि हम शुरू करें, यदि आप किसी समस्या का सामना करते हैं, तो मैंने फ़ुटनोट में कुछ समस्या निवारण चरण दिए हैं।

परीक्षण करने के लिए, आपके पास ब्लूटूथ कम ऊर्जा वाला iPhone होना चाहिए। अधिकांश आधुनिक iPhones में यह होता है। मेरा मानना ​​​​है कि आखिरी आईफोन नहीं था या तो आईफोन 4 या 3 जी था। (इसलिए आप शायद अच्छे हैं)

सबसे पहले, इसे अपने कंप्यूटर में प्लग करें।

प्ले और स्टॉप बटन द्वारा शीर्ष पर जाएं। अपने लक्ष्य डिवाइस का चयन करें। मेरे मामले में मैंने अपना फ़ोन चुना (Jared's iPhone ) आप iPad का भी उपयोग कर सकते हैं।

फिर आप Command + R . दबा सकते हैं या उस चलाएं बटन hit दबाएं ऐप को अपने फोन में लोड करने के लिए।

सुनिश्चित करें कि आपका लॉग टैब खुला है। ऊपरी दाएं कोने में निचले फलक बटन पर क्लिक करके इसे सक्षम करें।

सुनिश्चित करें कि आपके पास एक मेश डिवाइस सेटअप है और उदाहरण कोड चला रहा है। इसे पाने के लिए आप इस पोस्ट पर जा सकते हैं। याद रखें कि ब्लूटूथ के काम करने के लिए आपके पार्टिकल मेश बोर्ड पर डिवाइस OS 1.3.0 या इससे बड़ा होना चाहिए!

फ़र्मवेयर और ऐप दोनों लोड हो जाने के बाद, आइए लॉग आउटपुट की जाँच करें।

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

View loaded
Central state update
Central scanning for B4250400-FB4B-4746-B2B0-93F0E61122C6
Connected to your Particle Board
LED service found
Red LED characteristic found
Green LED characteristic found
Blue LED characteristic found

इसका मतलब है कि आपका फोन कनेक्ट हो गया है, एलईडी सेवा मिल गई है! खोजी जा रही विशेषताएँ भी यहाँ महत्वपूर्ण हैं। इनके बिना हम मेश डिवाइस पर डेटा नहीं भेज पाएंगे।

अगला कदम कुछ स्लाइडर बनाना है ताकि हम तुरंत आरजीबी मूल्यों को अपडेट कर सकें।

बाईं ओर स्लाइड करें। दाईं ओर स्लाइड करें।

आगे हम अपने Main.storyboard . में कुछ तत्व जोड़ने जा रहे हैं . Main.storyboardखोलें और देखें . पर क्लिक करें नीचे नियंत्रक देखें.

फिर लाइब्रेरी . पर क्लिक करें बटन। (ऐसा लगता है कि ऐप्पल होम बटन के लिए इस्तेमाल की जाने वाली पुरानी कला की तरह है)

आपको उन सभी विकल्पों के साथ एक पॉप-अप मिलेगा, जिन्हें आप अपने ऐप में सम्मिलित कर सकते हैं।

तीन लेबलखींचें और तीन स्लाइडर को कॉपी करें आपके विचार में।

आप लेबल पर डबल क्लिक कर सकते हैं और जाते ही उनका नाम बदल सकते हैं।

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

आप उन सभी का चयन भी कर सकते हैं और उन्हें एक साथ स्थानांतरित कर सकते हैं। हम उन्हें लंबवत और क्षैतिज रूप से संरेखित करेंगे।

उनके बीच में बने रहने के लिए, आइए ऑटोरेसाइज़िंग प्रॉपर्टी को हटा दें। शासक आइकन पर क्लिक करें ऊपर दाईं ओर। फिर प्रत्येक लाल बार . पर क्लिक करें . यह सुनिश्चित करेगा कि आपके लेबल और स्लाइडर स्क्रीन पर बने रहें!

इसके बाद सहायक संपादक दिखाएं . क्लिक करें बटन। (वेन आरेख जैसा दिखता है)

नोट: सुनिश्चित करें कि ViewController.swift आपके Assistant Editor में खुला है।

फिर /properties . के नीचे अनुभाग, कंट्रोल-क्लिक करें और खींचें लाल स्लाइडर आपके कोड में।

अन्य सभी के साथ दोहराएं। सुनिश्चित करें कि आप उन्हें कुछ अलग नाम दें। काम पूरा करने के बाद आपका कोड इस तरह दिखना चाहिए:

        // Properties
        private var centralManager: CBCentralManager!
        private var peripheral: CBPeripheral!

        // Sliders
        @IBOutlet weak var redSlider: UISlider!
        @IBOutlet weak var greenSlider: UISlider!
        @IBOutlet weak var blueSlider: UISlider!

यह हमें स्लाइडर के मूल्य तक पहुंचने की अनुमति देता है।

इसके बाद, मान परिवर्तित संलग्न करते हैं प्रत्येक स्लाइडर के लिए घटना। राइट क्लिक फ़ोल्डर दृश्य में लाल स्लाइडर पर।

यह आपको घटनाओं के लिए कुछ विकल्प देना चाहिए। क्लिक करें और खींचें मान परिवर्तित आपके कोड के लिए घटना। सुनिश्चित करें कि आप इसे कुछ ऐसा नाम दें जो समझ में आए। मैंने RedSliderChanged . का उपयोग किया लाल स्लाइडर के लिए।

दो बार और दोहराएं। इस चरण के अंत में आपका कोड इस तरह दिखना चाहिए:

        @IBAction func RedSliderChanged(_ sender: Any) {
        }

        @IBAction func GreenSliderChanged(_ sender: Any) {
        }

        @IBAction func BlueSliderChanged(_ sender: Any) {
        }

मैंने प्रत्येक स्लाइडर को अनचेक सक्षम . में भी चुना है . इस तरह आप उन्हें स्थानांतरित नहीं कर सकते। हम उन्हें बाद में कोड में सक्षम करेंगे।

साथ ही, अधिकतम मान को 255 . में बदलने का यह एक अच्छा समय है . साथ ही डिफ़ॉल्ट मान को 0.5 से 0 पर सेट करें।

फ़ाइल के शीर्ष पर वापस। आइए प्रत्येक विशेषता के लिए कुछ स्थानीय चर बनाएं। हम इनका उपयोग करेंगे ताकि हम पार्टिकल मेश बोर्ड पर स्लाइडर वेरिएबल लिख सकें।

        // Characteristics
        private var redChar: CBCharacteristic?
        private var greenChar: CBCharacteristic?
        private var blueChar: CBCharacteristic?

अब, चलो सब कुछ एक साथ बाँध लें!

didDiscoverCharacteristicsFor में कॉलबैक फ़ंक्शन। आइए उन विशेषताओं को असाइन करें। उदाहरण के लिए

    if characteristic.uuid == ParticlePeripheral.redLEDCharacteristicUUID {
        print("Red LED characteristic found")
        redChar = characteristic

जैसा कि हम प्रत्येक विशेषता को ढूंढते हैं, हम प्रत्येक स्लाइडर को एक ही स्थान पर सक्षम भी कर सकते हैं।

    		// Unmask red slider
    		redSlider.isEnabled = true

अंत में आपका didDiscoverCharacteristicsFor इस तरह दिखना चाहिए:

    // Handling discovery of characteristics
        func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
            if let characteristics = service.characteristics {
                for characteristic in characteristics {
                    if characteristic.uuid == ParticlePeripheral.redLEDCharacteristicUUID {
                        print("Red LED characteristic found")

                        redChar = characteristic
                        redSlider.isEnabled = true
                    } else if characteristic.uuid == ParticlePeripheral.greenLEDCharacteristicUUID {
                        print("Green LED characteristic found")

                        greenChar = characteristic
                        greenSlider.isEnabled = true
                    } else if characteristic.uuid == ParticlePeripheral.blueLEDCharacteristicUUID {
                        print("Blue LED characteristic found");

                        blueChar = characteristic
                        blueSlider.isEnabled = true
                    }
                }
            }
        }

अब, चलिए RedSliderChanged को अपडेट करते हैं GreenSliderChanged और BlueSliderChanged कार्य। हम यहां क्या करना चाहते हैं Changed . से जुड़ी विशेषता को अपडेट करना है समारोह। मैंने writeLEDValueToChar . नामक एक अलग फ़ंक्शन बनाया है . हम विशेषता और डेटा में पास करेंगे।

    private func writeLEDValueToChar( withCharacteristic characteristic: CBCharacteristic, withValue value: Data) {

            // Check if it has the write property
            if characteristic.properties.contains(.writeWithoutResponse) && peripheral != nil {

                peripheral.writeValue(value, for: characteristic, type: .withoutResponse)

            }

        }

अब writeLEDValueToChar . पर कॉल जोड़ें प्रत्येक Changed . को कार्य। आपको मान को Uint8 . पर डालना होगा . (पार्टिकल मेश डिवाइस एक अहस्ताक्षरित 8-बिट संख्या की अपेक्षा करता है।)

    		@IBAction func RedSliderChanged(_ sender: Any) {
            print("red:",redSlider.value);
            let slider:UInt8 = UInt8(redSlider.value)
            writeLEDValueToChar( withCharacteristic: redChar!, withValue: Data([slider]))

        }

इसे GreenSliderChanged . के लिए दोहराएं और BlueSliderChanged . सुनिश्चित करें कि आपने red बदल दिया है से green और blue प्रत्येक के लिए!

अंत में, चीजों को साफ रखने के लिए, मैंने एक फ़ंक्शन भी जोड़ा है जो ब्लूटूथ डिस्कनेक्ट को संभालता है।

    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {

अंदर, हमें स्लाइडर की स्थिति को 0 पर रीसेट करना चाहिए और उन्हें अक्षम करना चाहिए।

            if peripheral == self.peripheral {
                print("Disconnected")

                redSlider.isEnabled = false
                greenSlider.isEnabled = false
                blueSlider.isEnabled = false

                redSlider.value = 0
                greenSlider.value = 0
                blueSlider.value = 0

self.peripheral reset को रीसेट करना एक अच्छा विचार है इस तरह से शून्य करने के लिए हम कभी भी एक प्रेत डिवाइस पर लिखने की कोशिश नहीं कर रहे हैं।

                self.peripheral = nil

अंत में, क्योंकि हमने डिस्कनेक्ट कर दिया है, फिर से स्कैन करना शुरू करें!

                // Start scanning again
                print("Central scanning for", ParticlePeripheral.particleLEDServiceUUID);
                centralManager.scanForPeripherals(withServices: [ParticlePeripheral.particleLEDServiceUUID],
                                                  options: [CBCentralManagerScanOptionAllowDuplicatesKey : true])
            }

ठीक है! हम अभी परीक्षण के लिए तैयार हैं। आइए अगले (और अंतिम) चरण पर चलते हैं।

स्लाइडर का परीक्षण करें।

मेहनत तो की जाती है। अब खेलने का समय है!

सब कुछ जांचने का सबसे आसान तरीका है चलाएं बटन पर क्लिक करें ऊपर बाईं ओर या कमांड + आर कुंजीपटल संक्षिप्त रीति। Xcode ऐप को आपके फोन में लोड कर देगा। आपको अपने स्लाइडर के साथ एक स्क्रीन द्वारा आगे बढ़ती एक सफेद स्क्रीन दिखाई देनी चाहिए!

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

View loaded
Central state update
Central scanning for B4250400-FB4B-4746-B2B0-93F0E61122C6
Connected to your Particle Board
LED service found
Red LED characteristic found
Green LED characteristic found
Blue LED characteristic found

(परिचित लग रहे हैं? हम जुड़े हुए हैं!)

यदि आपने सब कुछ पूरी तरह से पालन किया है, तो आपको स्लाइडर्स को स्थानांतरित करने में सक्षम होना चाहिए। बेहतर अभी तक, कण जाल बोर्ड पर आरजीबी एलईडी रंग बदलना चाहिए।

निष्कर्ष

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

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

कोड

पूर्ण स्रोत कोड Github पर उपलब्ध है। यदि आप इसे उपयोगी पाते हैं, तो स्टार बटन दबाएं। ️