एक जेस्चर सेंसर के साथ एक Neopixel एलईडी रिंग को नियंत्रित करना: 3 चरण (चित्रों के साथ)

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:22

इस ट्यूटोरियल में हम एक Arduino UNO का उपयोग करके उन दोनों को संयोजित करने का तरीका जानने के लिए एक जेस्चर सेंसर (APDS-9960) और एक नियोपिक्सल रिंग के साथ खेलने जा रहे हैं।

अंतिम उत्पाद बाएं-दाएं इशारों पर लेड मूवमेंट को दाएं या बाएं एनिमेट करके, और एलईडी रंग बदलकर ऊपर-नीचे इशारों का जवाब देगा।

अगले चरणों में, आप संक्षेप में भाग सूची और घटकों को जोड़ने के तरीके का अवलोकन करेंगे। और फिर हम यह जानने के लिए कोड की चरण दर चरण समीक्षा करेंगे कि यह कैसे काम करता है।

चरण 1: अवयव

1. अरुडिनो यूएनओ

2. यूएसबी केबल

3. APDS9960 जेस्चर सेंसर (https://www.sparkfun.com/products/12787)

4. 24 एलईडी नियोपिक्सल एलईडी रिंग (https://www.adafruit.com/product/1586)

5. नर-मादा, नर-नर ब्रेडबोर्ड केबल

6. ब्रेडबोर्ड

7. एलईडी रिंग के लिए 5 वी बिजली की आपूर्ति (मैं 4 बैटरी बैक का उपयोग कर रहा हूं)

8. नियोपिक्सल रिंग को ब्रेडबोर्ड से जोड़ने के लिए आपको इसमें तीन पुरुष पिन मिलाप करने होंगे: GND, PWR, और कंट्रोल पिन। इसके लिए आपको एक सोल्डरिंग आयरन और फ्लक्स की आवश्यकता होगी

यहां मुख्य घटक APDS-9960 जेस्चर सेंसर और 24 नियोपिक्सल रिंग हैं। आप अपनी इच्छानुसार विभिन्न arduinos, usb केबल बिजली की आपूर्ति और ब्रेडबोर्ड को स्विच कर सकते हैं।

चरण 2: विधानसभा और अपलोड

सभा

आरंभ करने से पहले सुनिश्चित करें कि आपके पास टेबल पर सभी घटक हैं। हमारे पास अनुसरण करने के लिए कुछ अच्छे कदम होंगे:)। मैंने फ्रिट्ज़िंग योजनाबद्ध को चित्र के रूप में और फ़्रिट्ज़िंग प्रारूप में भी संलग्न किया है।

1. नियोपिक्सल रिंग (GND, PWR, कंट्रोल पिन) में 3 पुरुष पिन मिलाप करें

2. नियोपिक्सल रिंग को ब्रेडबोर्ड से जोड़ दें

3. APDS9960 सेंसर को ब्रेडबोर्ड से जोड़ें

4. ग्राउंड कनेक्ट करें: ब्रेडबोर्ड ग्राउंड में बैटरी पैक, arduino UNO, APDS9960 और neopixel

5. पावर कनेक्ट करें: arduino UNO 3V से APDS9960 पावर पिन, नियोपिक्सल से बैटरी पैक पावर

6. नियोपिक्सल कंट्रोल पिन को arduino D6 pin. से कनेक्ट करें

7. APDS9960 के SDA और SCL को क्रमशः A4 और A5 से कनेक्ट करें

8. APDS9960 इंटरप्ट पिन को arduino D2. से कनेक्ट करें

कोड अपलोड

सबसे पहले आपको आवश्यक arduino लाइब्रेरी को डाउनलोड और इंस्टॉल करना होगा:

1. नियोपिक्सल रिंग लाइब्रेरी:

2. जेस्चर सेंसर लाइब्रेरी:

यदि आप नहीं जानते कि आर्डिनो लाइब्रेरी कैसे स्थापित करें, तो इस ट्यूटोरियल को देखें।

आपके द्वारा उपरोक्त पुस्तकालयों को डाउनलोड और स्थापित करने के बाद, आप यहाँ स्थित मेरे arduino रिपॉजिटरी को क्लोन या डाउनलोड कर सकते हैं: https://github.com/danionescu0/arduino, और हम इस स्केच का उपयोग करेंगे: https://github.com/danionescu0 /arduino/पेड़/मास्टर/प्रोजेक्ट्स/neopixel_ring_gestures

अगले भाग में मैं सीधे इस ट्यूटोरियल में कोड एम्बेड करूँगा, इसलिए यदि आप चाहें तो इसे वहाँ से कॉपी और पेस्ट कर सकते हैं।

अंत में USB केबल का उपयोग करके arduino को कंप्यूटर से कनेक्ट करें, बैटरी पैक में 1.5 v बैटरी डालें, और स्केच को arduino में अपलोड करें।

चरण 3: यह कैसे काम करता है?

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

आइए पहले सेंसर और नियोपिक्सल लाइब्रेरी एपीआई विधियों के माध्यम से एक त्वरित नज़र डालें जिनका हम उपयोग करेंगे

1. एडफ्रूट से नियोपिक्सल एपीआई

इस पुस्तकालय से हम उन विधियों का उपयोग करेंगे जो व्यक्तिगत एलईडी के रंग को नियंत्रित करती हैं और उन्हें लागू करती हैं

- पुस्तकालय शामिल करें:

#शामिल

- पुस्तकालय घोषित करें

#NEOPIXED_CONTROL_PIN 6 परिभाषित करें

#define NUM_LEDS 24 Adafruit_NeoPixel स्ट्रिप = Adafruit_NeoPixel(NUM_LEDS, NEOPIXED_CONTROL_PIN, NEO_RBG + NEO_KHZ800);

- प्रारंभ करें

#आमतौर पर सेटअप ब्लॉक के अंदर

शून्य सेटअप () { पट्टी। शुरू (); #शायद यहाँ कुछ और सामान #…. }

- अलग-अलग पिक्सल को हल्का करें और फिर सभी संशोधनों को पट्टी पर लागू करें (इसे एक तरह से प्रस्तुत करें)

# पिक्सेल 0 को लाल होने के लिए सेट करें

स्ट्रिप.सेट पिक्सेलकलर (0, स्ट्रिप। कलर (255, 0, 0)); # पिक्सेल 1 को हरे रंग की पट्टी के रूप में सेट करें। सेट पिक्सेल रंग (1, पट्टी। रंग (0, 255, 0)); # पिक्सेल 2 को नीली पट्टी के रूप में सेट करें। सेट पिक्सेल रंग (2, पट्टी। रंग (0, 0 255)); कपड़े उतारने का प्रदर्शन();

2. एपीडीएस 9960 जेस्चर सेंसर

इस लाइब्रेरी से हम "रीड जेस्चर" फ़ंक्शन का उपयोग करेंगे। यह फ़ंक्शन लेफ्ट-राइट, अप-डाउन, क्लोज-दूर कमांड के बीच अंतर करने में सक्षम होगा। यहां एक तरकीब है, हम सेंसर से लगातार आखिरी जेस्चर के बारे में नहीं पूछेंगे। बोर्ड में एक बाधा के माध्यम से "पिंग" करने की क्षमता है जो एक इशारा पाया गया है।

- पुस्तकालय को शामिल करें, नियोपिक्सेल के समान

- पुस्तकालय को इंटरप्ट पिन और इंटरप्ट फ्लैग घोषित करें

#परिभाषित करें APDS9960_INT 2

SparkFun_APDS9960 एपीडीएस = SparkFun_APDS9960 (); int isr_flag = 0;

- लाइब्रेरी को इनिशियलाइज़ करें, आमतौर पर सेटअप फंक्शन के अंदर

व्यर्थ व्यवस्था()

{# इंटरप्ट पिन को INPUT घोषित करें और उसमें एक फ़ंक्शन संलग्न करें pinMode(APDS9960_INT, INPUT); अटैचइंटरप्ट (0, इंटरप्टरूटीन, फॉलिंग); अगर (apds.init() && apds.enableGestureSensor(true)) { Serial.println ("APDS-9960 आरंभीकरण पूर्ण"); } और { Serial.println ("APDS-9960 init के दौरान कुछ गलत हो गया!"); } # शायद अन्य चीजों को प्रारंभ करें }

- इंटरप्ट फ़ंक्शन को परिभाषित करें, यहां हम केवल एक ध्वज सेट करेंगे

शून्य व्यवधान रूटीन () {

isr_flag = 1; }

- लूप फ़ंक्शन के अंदर समय-समय पर ध्वज की जांच करें कि क्या कोई इशारा पाया गया है

शून्य लूप ()

{# ध्वज की जांच करें यदि (isr_flag == 1) {# यदि ध्वज सेट है, तो व्यवधान को हटा दें, हैंडलगेचर () फ़ंक्शन के अंदर आवश्यक प्रसंस्करण करें # और फिर ध्वज को रीसेट करें और इंटरप्ट को फिर से संलग्न करें detachInterrupt(0); हैंडल जेस्चर (); isr_flag = 0; अटैचइंटरप्ट (0, इंटरप्टरूटीन, फॉलिंग); } # यहां कोई अन्य कोड हो सकता है }

- हैंडल जेस्चर () फ़ंक्शन को परिभाषित करें जहां हम अंतिम इशारे के लिए पूछ सकते हैं

शून्य हैंडल जेस्चर () {

# यदि कोई इशारा उपलब्ध नहीं है, तो यह केवल एक सुरक्षित जांच है अगर (!apds.isGestureAvailable ()) {वापसी; } # अंतिम इशारा पढ़ता है, ज्ञात लोगों के साथ तुलना करता है और एक संदेश स्विच प्रिंट करता है (apds.readGesture()) {केस DIR_UP: Serial.println("UP"); टूटना; मामला DIR_DOWN: Serial.println ("डाउन"); टूटना; मामला DIR_LEFT: Serial.println ("बाएं"); टूटना; मामला DIR_RIGHT: Serial.println ("राइट"); टूटना; मामला DIR_FAR: Serial.println ("FAR"); टूटना; } }

आइए अब पूरे कोड को क्रिया में देखें:

तो मैंने जेस्चर सेंसर और नियोपिक्सल रिंग के बेस एपीआई के बारे में बताया है, अब चीजों को एक साथ रखते हैं:

एल्गोरिथ्म इस तरह चलता है:

- पुस्तकालयों को प्रारंभ करें (उपरोक्त कोड देखें)

- "ledStates" नामक एलईडी तीव्रता की एक सरणी बनाएं। इस सरणी में २४ एलईडी तीव्रताएं होंगी जो १५० से २. तक अवरोही तरीके से व्यवस्थित की जाती हैं

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

- "हैंडल जेस्चर ()" फ़ंक्शन अंतिम इशारा की जांच करता है और यूपी-डाउन जेस्चर के लिए "टॉगलकलर" फ़ंक्शन को कॉल करता है या बाएं - दाएं इशारों के लिए एक वैश्विक चर "ledDirection" सेट करता है

- "toggleColor ()" फ़ंक्शन केवल 0, 1, 2 मानों में से एक के साथ "colorSelection" नामक एक वैश्विक चर को बदलता है

- मुख्य लूप के अंदर भी "animateLeds ();" नामक एक अन्य फ़ंक्शन फ़ंक्शन करता है। कहा जाता है। यह फ़ंक्शन जांचता है कि क्या 100 मिलीसेकंड बीत चुके हैं, और यदि ऐसा है तो यह "रोटेटलेड्स ()" फ़ंक्शन का उपयोग करके एलईडी को घुमाता है और फिर उन्हें फिर से खींचता है

- "रोटेट लेड्स ()" "इंटरमीडिएट लेडस्टेट्स" नामक एक अन्य सरणी का उपयोग करके लीड्स को आगे या पीछे "घुमाएगा"।

रोटेशन "प्रभाव" इस तरह दिखेगा:

# आरंभीकरण के बाद

{१५०, १००, ७०, ५०, ४०, ३०, १०, २, ०, ०, ०, ०, ०, ०, ०, ०, ०, ०, ०, ०, ०, ०, ०, ०}; # रोटेट के बाद () को {0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, कहा जाता है। 0, 0, 0}; # रोटेट करने के बाद () को फिर से {0, 0, 150, 100, 70, 50, 40, 30, 10, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 कहा जाता है।, 0, 0, 0}; # और इसी तरह

इसके लिए पहले नया एरे बनाता है और नई पोजीशन पर पुराने एलईडी इंटेंसिटी को कॉपी करता है (पोजिशन बढ़ाएं या घटाएं)। उसके बाद यह "ledStates" सरणी को "intermediateLedStates" के साथ अधिलेखित कर देता है, इसलिए प्रक्रिया 100 मिलीसेकंड के बाद भी जारी रहेगी।

#शामिल "SparkFun_APDS9960.h"

#शामिल "Adafruit_NeoPixel.h"

#include "Wire.h" #define NEOPIXED_CONTROL_PIN 6 #define NUM_LEDS 24 #define APDS9960_INT 2 #define LED_SPEED_STEP_INTERVAL 100 Adafruit_NeoPixel स्ट्रिप = Adafruit_NeoPixel (NUM_LEDS, NEOPIXED_CONTROL_CONTROL); SparkFun_APDS9960 एपीडीएस = SparkFun_APDS9960 (); अहस्ताक्षरित लंबा lastLedChangeTime = 0; लघु नेतृत्व दिशा = 0; लघु रंग चयन = 0; बाइट लेडस्टेट्स = {१५०, १००, ७०, ५०, ४०, ३०, १०, २, ०, ०, ०, ०, ०, ०, ०, ०, ०, ०, ०, ०, ०, ०, 0, 0}; int isr_flag = 0; शून्य सेटअप () {Serial.begin (९६००); Serial.println ("कार्यक्रम शुरू हुआ"); पट्टी। शुरू (); पिनमोड (APDS9960_INT, INPUT); अटैचइंटरप्ट (0, इंटरप्टरूटीन, फॉलिंग); अगर (apds.init() && apds.enableGestureSensor(true)) { Serial.println ("APDS-9960 आरंभीकरण पूर्ण"); } और { Serial.println ("APDS-9960 init के दौरान कुछ गलत हो गया!"); } lastLedChangeTime = मिली (); Serial.println ("सफलतापूर्वक प्रारंभ करें"); } शून्य लूप () { अगर (isr_flag == 1) { detachInterrupt (0); हैंडल जेस्चर (); isr_flag = 0; अटैचइंटरप्ट (0, इंटरप्टरूटीन, फॉलिंग); } एनिमेटलेड्स (); } शून्य रुकावट रूटीन () {isr_flag = 1; } /** * यह APDS9960 सेंसर से इशारों को संभालेगा * ऊपर और नीचे के जेस्चर टॉगलकलर फ़ंक्शन को कॉल करेंगे * बाएँ और दाएँ जेस्चर एलईडी एनीमेशन को बदल देंगे */ शून्य हैंडलगेचर () {if (!apds.isGestureAvailable ()) {वापसी; } स्विच (apds.readGesture()) {केस DIR_UP: Serial.println("UP"); टॉगल रंग (); टूटना; मामला DIR_DOWN: Serial.println ("डाउन"); टॉगल रंग (); टूटना; मामला DIR_LEFT: एलईडीदिशा = 1; Serial.println ("बाएं"); टूटना; मामला DIR_RIGHT: एलईडीदिशा = -1; Serial.println ("राइट"); टूटना; मामला DIR_FAR: एलईडीदिशा = 0; Serial.println ("FAR"); टूटना; } } /** * वर्तमान एलईडी रंग बदलें * हर बार इस फ़ंक्शन को कॉल करने पर एलईडी स्थिति बदल जाएगी */ शून्य टॉगल रंग () { अगर (रंग चयन == 0) {रंग चयन = 1; } और अगर (रंग चयन == 1) {रंग चयन = 2; } और {रंग चयन = 0; } } /** * एनिमेशन LED_SPEED_STEP_INTERVAL मिलिस के बाद चलेगा; } रोटेट लेड्स (); के लिए (int i=0; i < NUM_LEDS; i++) {trip.setPixelColor(i, getColor(ledStates)); कपड़े उतारने का प्रदर्शन(); } lastLedChangeTime = मिली (); } /** * एक द्वितीयक सरणी "इंटरमीडिएट लेडस्टेट्स" का उपयोग करते हुए, एलईडी तीव्रता एनिमेटेड होती है * पहले "लीडस्टेट्स" के मानों को "इंटरमीडिएट लेडस्टेट्स" पर कॉपी किया जाता है, जैसे * "लीडस्टेट्स" सरणी {100, 80, 60, 0, 0, 0} और लेडडायरेक्शन 1 * है, फिर इस फ़ंक्शन को "ledStates" कहा जाता है, सरणी {0, 100, 80, 60, 0, 0} है जो एक रोटेशन प्रभाव का अनुकरण करता है */ void रोटेट लेड्स () { बाइट इंटरमीडिएट लेडस्टेट्स [NUM_LEDS]; के लिए (int i=0; i < NUM_LEDS; i++) { इंटरमीडिएटलेडस्टेट्स = 0; } के लिए (int i=0; i < NUM_LEDS; i++) { if (ledDirection == 1) { if (i == NUM_LEDS -1) { मध्यवर्तीLedStates [0] = ledStates; } और { इंटरमीडिएट लेडस्टेट्स [i + 1] = एलईडीस्टेट्स ; } } और { अगर (i == 0) { इंटरमीडिएट लेडस्टेट्स [NUM_LEDS - 1] = एलईडीस्टेट्स ; } और { इंटरमीडिएट लेडस्टेट्स [i - 1] = लेडस्टेट्स ; } } } के लिए (int i=0; i < NUM_LEDS; i++) {ledStates = मध्यवर्तीLedStates; } } uint32_t getColor (int तीव्रता) {स्विच (रंग चयन) {केस 0: वापसी पट्टी। रंग (तीव्रता, 0, 0); केस 1: वापसी पट्टी। रंग (0, तीव्रता, 0); डिफ़ॉल्ट: वापसी पट्टी। रंग (0, 0, तीव्रता); } }

मुझे आशा है कि आपको यह पसंद आया होगा, आप मुझसे प्रश्न पूछने के लिए टिप्पणी अनुभाग का उपयोग कर सकते हैं।