पिछले ट्यूटोरियल में, आपने सीखा कि Particle Xenon एप्लिकेशन में ब्लूटूथ कैसे जोड़ा जाता है। इस तरह आप ऑनबोर्ड RGB LED को nRF Connect या Light Blue Explorer जैसे टेस्ट ऐप से नियंत्रित कर सकते थे।
इस पोस्ट में, हम इसे एक कदम आगे ले जा रहे हैं। हम Particle Mesh RGB LED को नियंत्रित करने के लिए एक Swift ऐप विकसित करने जा रहे हैं। अगर सब ठीक रहा, तो आपके पास लगभग 20 मिनट में एक काम करने वाला ऐप होगा!
शुरू करते हैं।
अभी पूरा लेख पढ़ने का समय नहीं है?
यहां PDF संस्करण डाउनलोड करें।
सेट अप करना
- Xcode इंस्टॉल करें। आप इसे यहां App Store से डाउनलोड कर सकते हैं।
- आपको एक Apple लॉगिन की भी आवश्यकता होगी। मैं अपने iCloud ईमेल का उपयोग करता हूं। यदि आपके पास अभी तक एक नहीं है, तो आप Xcode के भीतर एक नया खाता बना सकते हैं।
- Particle Mesh बोर्ड पर RGB उदाहरण कोड इंस्टॉल करें।
प्रोजेक्ट बनाएं
एक बार सब कुछ इंस्टॉल हो जाने पर, आइए मजेदार चीजों पर चलते हैं!
Xcode खोलें और File → New Project पर जाएं।
Single View App चुनें।
फिर Project Name को अपनी पसंद के अनुसार अपडेट करें। मैंने अपना ऑर्गनाइजेशन आइडेंटिफायर 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 यह हमें iOS में ब्लूटूथ लो एनर्जी कार्यक्षमता को नियंत्रित करने की अनुमति देता है। फिर 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 कहें। इसे कहीं भी रखा जा सकता है लेकिन मैंने इसे बाद के लिए Models नामक एक अलग 'ग्रुप' में रखा।
अंदर हम कुछ पब्लिक वेरिएबल बनाएंगे जिनमें हमारे Particle बोर्ड के लिए UUIDs होंगे। वे परिचित दिखने चाहिए!
import UIKit import CoreBluetooth class ParticlePeripheral: NSObject { /// MARK: - Particle LED सर्विसेज और कैरेक्टरिस्टिक्स आइडेंटिफायर्स 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 इवेंट प्रदान किए गए सर्विस UUID का उपयोग करके सभी कैरेक्टरिस्टिक्स प्रदान करेगा। यह पूर्ण डिवाइस डिस्कवरी करने की श्रृंखला में अंतिम चरण है। यह जटिल है लेकिन कनेक्शन चरण के दौरान केवल एक बार किया जाना है!
सभी ब्लूटूथ फ़ंक्शंस को परिभाषित करना।
अब जब हम जानते हैं कि कौन से फ़ंक्शन इवेंट्स ट्रिगर होते हैं। हम उन्हें तार्किक क्रम में परिभाषित करेंगे जो कनेक्शन चक्र के दौरान होता है।
पहले, हम centralManagerDidUpdateState को परिभाषित करेंगे ताकि हमारे Particle RGB LED सर्विस वाले डिवाइस के लिए स्कैनिंग शुरू हो सके। यदि ब्लूटूथ सक्षम नहीं है, तो यह कुछ नहीं करेगा।
// अगर हम पावर्ड ऑन हैं, तो स्कैनिंग शुरू करें 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 को परिभाषित करना प्रक्रिया में हमारा अगला कदम है। हम जानते हैं कि हमें एक डिवाइस मिला है अगर यह इवेंट हुआ है।
// स्कैन के परिणाम को संभालता है func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) { // हमें यह मिल गया इसलिए स्कैन बंद करें self.centralManager.stopScan() // पेरिफेरल इंस्टेंस कॉपी करें self.peripheral = peripheral self.peripheral.delegate = self // कनेक्ट करें! self.centralManager.connect(self.peripheral, options: nil) } तो, हम self.centralManager.stopScan() का उपयोग करके स्कैनिंग बंद करते हैं। हम peripheral सेट करते हैं ताकि यह ऐप के माध्यम से बना रहे। फिर हम self.centralManager.connect का उपयोग करके उस डिवाइस से कनेक्ट करते हैं।
एक बार कनेक्ट होने पर, हमें दोबारा जांचना होगा कि क्या हम सही डिवाइस के साथ काम कर रहे हैं।
// हैंडलर अगर हम सफलतापूर्वक कनेक्ट करते हैं 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 इवेंट मिलेगा। हम सभी "उपलब्ध" सर्विसेज के माध्यम से पुनरावृति करेंगे। (हालांकि केवल एक ही होगी!)
// डिस्कवरी इवेंट को संभालता है 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") //अब कैरेक्टरिस्टिक्स की डिस्कवरी शुरू करें peripheral.discoverCharacteristics([ParticlePeripheral.redLEDCharacteristicUUID, ParticlePeripheral.greenLEDCharacteristicUUID, ParticlePeripheral.blueLEDCharacteristicUUID], for: service) return } } } } इस बिंदु पर यह तीसरी बार है जब हम यह सुनिश्चित करने के लिए जांच कर रहे हैं कि हमारे पास सही सर्विस है। बाद में जब कई कैरेक्टरिस्टिक्स और कई सर्विसेज होंगी तो यह अधिक काम आएगा।
हम peripheral.discoverCharacteristics को उन कैरेक्टरिस्टिक्स के UUIDs की एक सरणी के साथ कॉल करते हैं जिन्हें हम ढूंढ रहे हैं। वे सभी UUIDs हैं जिन्हें हमने ParticlePeripheral.swift में परिभाषित किया था।
अंत में, हम didDiscoverCharacteriscsFor इवेंट को संभालते हैं। हम सभी उपलब्ध कैरेक्टरिस्टिक्स के माध्यम से पुनरावृति करते हैं। जैसे ही हम पुनरावृति करते हैं, हम उनकी तुलना उनसे करते हैं जिन्हें हम ढूंढ रहे हैं।
// कैरेक्टरिस्टिक्स की डिस्कवरी को संभालना 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"); } } } } इस बिंदु पर हम अपने Particle Mesh डिवाइस की पूर्ण डिवाइस डिस्कवरी करने के लिए तैयार हैं। अगले भाग में हम यह जांचेंगे कि हमारे पास क्या है यह सुनिश्चित करने के लिए कि चीजें ठीक काम कर रही हैं।
हमारे न्यूनतम उदाहरण का परीक्षण
शुरू करने से पहले, यदि आप परेशानी में पड़ते हैं तो मैंने फुटनोट्स में कुछ समस्या निवारण चरण रखे हैं।
परीक्षण के लिए, आपके पास ब्लूटूथ लो एनर्जी वाला iPhone होना चाहिए। अधिकांश आधुनिक iPhones में यह होता है। आखिरी iPhone जिसमें यह नहीं था, मुझे लगता है कि iPhone 4 या 3Gs था। (तो आप शायद ठीक हैं)
सबसे पहले, इसे अपने कंप्यूटर में प्लग करें।
प्ले और स्टॉप बटन के पास ऊपर जाएं। अपना टार्गेट डिवाइस चुनें। मेरे मामले में मैंने अपना फोन चुना (Jared's iPhone)। आप iPad का भी उपयोग कर सकते हैं।
फिर आप Command + R दबा सकते हैं या उस Play बटन को दबाकर ऐप को अपने फोन पर लोड कर सकते हैं।
सुनिश्चित करें कि आपका लॉग टैब खुला है। शीर्ष दाएं कोने में नीचे फलक बटन पर क्लिक करके इसे सक्षम करें।
सुनिश्चित करें कि आपके पास एक मेश डिवाइस सेट अप है और उदाहरण कोड चला रहा है। आप इसे प्राप्त करने के लिए इस पोस्ट पर जा सकते हैं। याद रखें कि आपके Particle Mesh बोर्ड को ब्लूटूथ के काम करने के लिए डिवाइस 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 इसका मतलब है कि आपका फोन कनेक्ट हो गया है, LED सर्विस मिल गई है! कैरेक्टरिस्टिक्स का भी पता लगाया जाना यहां महत्वपूर्ण है। उनके बिना हम मेश डिवाइस को डेटा नहीं भेज पाएंगे।
अगला कदम कुछ स्लाइडर्स बनाना है ताकि हम RGB वैल्यूज़ को ऑन-द-फ्लाई अपडेट कर सकें।
बाईं ओर स्लाइड करें। दाईं ओर स्लाइड करें।
अब हम अपने Main.storyboard में कुछ एलिमेंट्स जोड़ने जा रहे हैं। Main.storyboard खोलें और View Controller के नीचे View पर क्लिक करें।
फिर Library बटन पर क्लिक करें। (यह पुराने आर्ट की तरह दिखता है जिसे Apple होम बटन के लिए इस्तेमाल करता था)
आपको एक पॉप-अप मिलेगा जिसमें वे सभी विकल्प होंगे जिन्हें आप अपने ऐप में डाल सकते हैं।
तीन Labels और तीन Sliders को अपने व्यू में ड्रैग करें।
आप लेबल्स पर डबल क्लिक करके उन्हें रास्ते में रीनेम कर सकते हैं।
यदि आप क्लिक करके होल्ड करते हैं, तो कुछ आसान अलाइनमेंट टूल्स पॉप अप होंगे। वे सेंटर पर स्नैप भी करेंगे!
आप उन सभी को चुनकर एक साथ ले जा सकते हैं। हम उन्हें वर्टिकली और हॉरिजॉन्टली अलाइन करेंगे।
उन्हें बीच में रखने के लिए, ऑटोरिसाइज़िंग प्रॉपर्टी को हटा दें। शीर्ष दाएं पर Ruler आइकन पर क्लिक करें। फिर प्रत्येक लाल बार पर क्लिक करें। यह सुनिश्चित करेगा कि आपके लेबल्स और स्लाइडर्स स्क्रीन पर रहें!
अब Show Assistant Editor बटन पर क्लिक करें। (वेन डायग्राम की तरह दिखता है)
नोट: सुनिश्चित करें कि ViewController.swift आपके Assistant Editor में खुला है।
फिर /properties सेक्शन के तहत, Control-click और ड्रैग करें Red Slider को अपने कोड में।
बाकी सभी के साथ दोहराएं। सुनिश्चित करें कि आप उन्हें कुछ अलग नाम देते हैं। जब आपका काम हो जाए तो आपका कोड इस तरह दिखना चाहिए:
// 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! यह हमें स्लाइडर्स के वैल्यू तक पहुंचने की अनुमति देता है।
अब, प्रत्येक स्लाइडर से Value Changed इवेंट जोड़ें। फोल्डर व्यू में Red Slider पर राइट क्लिक करें।
यह आपको इवेंट्स के लिए कुछ विकल्प देगा। Value Changed इवेंट को अपने कोड पर क्लिक करके ड्रैग करें। सुनिश्चित करें कि आप इसे कुछ ऐसा नाम देते हैं जो समझ में आए। मैंने रेड स्लाइडर के लिए RedSliderChanged का उपयोग किया।
दो बार और दोहराएं। इस चरण के अंत में आपका कोड इस तरह दिखना चाहिए:
@IBAction func RedSliderChanged(_ sender: Any) { } @IBAction func GreenSliderChanged(_ sender: Any) { } @IBAction func BlueSliderChanged(_ sender: Any) { } मैंने प्रत्येक स्लाइडर को भी चुना है और Enabled अनचेक किया। इस तरह आप उन्हें नहीं हिला सकते। हम बाद में कोड में उन्हें सक्षम करेंगे।
साथ ही, यह अधिकतम मूल्य को 255 में बदलने का एक अच्छा समय है। साथ ही डिफ़ॉल्ट मान को 0.5 से 0 पर सेट करें।
फ़ाइल के शीर्ष पर वापस। प्रत्येक कैरेक्टरिस्टिक के लिए कुछ स्थानीय वेरिएबल बनाएं। हम इनका उपयोग करेंगे ताकि हम स्लाइडर वेरिएबल्स को Particle Mesh बोर्ड पर लिख सकें।
// 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 जैसे ही हमें प्रत्येक कैरेक्टरिस्टिक मिलती है, हम उसी स्थान पर प्रत्येक स्लाइडर को सक्षम भी कर सकते हैं।
// रेड स्लाइडर अनमास्क करें redSlider.isEnabled = true अंत में आपका didDiscoverCharacteristicsFor इस तरह दिखना चाहिए:
// कैरेक्टरिस्टिक्स की डिस्कवरी को संभालना 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) { // जांचें कि क्या इसमें राइट प्रॉपर्टी है if characteristic.properties.contains(.writeWithoutResponse) && peripheral != nil { peripheral.writeValue(value, for: characteristic, type: .withoutResponse) } } अब प्रत्येक Changed फ़ंक्शन में writeLEDValueToChar को कॉल करें। आपको वैल्यू को Uint8 में कास्ट करना होगा। (Particle Mesh डिवाइस एक अनसाइन्ड 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 को nil पर रीसेट करना एक अच्छा विचार है ताकि हम कभी भी किसी फैंटम डिवाइस पर लिखने की कोशिश न करें।
self.peripheral = nil अंत में, चूंकि हम डिस्कनेक्ट हो गए हैं, फिर से स्कैनिंग शुरू करें!
// फिर से स्कैनिंग शुरू करें print("Central scanning for", ParticlePeripheral.particleLEDServiceUUID); centralManager.scanForPeripherals(withServices: [ParticlePeripheral.particleLEDServiceUUID], options: [CBCentralManagerScanOptionAllowDuplicatesKey : true]) } ठीक है! हम परीक्षण के लिए लगभग तैयार हैं। आइए अगले (और अंतिम) चरण पर चलते हैं।
स्लाइडर्स का परीक्षण करें।
कड़ी मेहनत हो चुकी है। अब खेलने का समय है!
सब कुछ टेस्ट करने का सबसे आसान तरीका शीर्ष बाएं में Play बटन पर क्लिक करना या Command + R कीबोर्ड शॉर्टकट है। Xcode ऐप को आपके फोन पर लोड करेगा। आपको एक सफेद स्क्रीन दिखाई देगी जिसके बाद आपके स्लाइडर्स वाली स्क्रीन आएगी!
स्लाइडर्स ग्रे आउट रहेंगे जब तक कि आपके Particle Mesh बोर्ड से कनेक्ट न हो जाएं। आप अपने लॉग आउटपुट की जांच कर सकते हैं कि कनेक्शन स्थापित हुआ है या नहीं।
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 (परिचित लग रहा है? हम कनेक्टेड हैं!)
यदि आपने सब कुछ पूरी तरह से फॉलो किया है, तो आप स्लाइडर्स को हिला पाएंगे। बेहतर अभी तक, Particle Mesh बोर्ड पर RGB LED रंग बदलना चाहिए।
निष्कर्ष
इस लेख में आपने सीखा कि अपने Particle Mesh बोर्ड और iOS डिवाइस को ब्लूटूथ पर कैसे कनेक्ट करें। हमने सीखा कि प्रत्येक उपलब्ध कैरेक्टरिस्टिक से कैसे कनेक्ट करें। साथ ही, इसके ऊपर, एक साफ इंटरफेस बनाकर यह सब करें।
जैसा कि आप कल्पना कर सकते हैं, आप iOS पर ब्लूटूथ के साथ रैबिट होल में जा सकते हैं। मेरी आगामी गाइड में और भी बहुत कुछ आ रहा है: The Ultimate Guide to Particle Mesh. मेरी सूची के सब्सक्राइबर्स को प्री-लॉन्च कंटेंट और लॉन्च होने पर छूट मिलती है! साइन अप करने के लिए यहां क्लिक करें।
कोड
पूरा सोर्स कोड GitHub पर उपलब्ध है। यदि आपको यह उपयोगी लगता है, तो स्टार बटन दबाएं। ⭐️
