रिलैक्सेशन गॉगल्स - आईटीटीटी: 5 कदम (चित्रों के साथ)

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

एचकेयू परियोजना - आईटीटीटी (यदि यह तो वह है) - जूलिया बर्कौवर, 1बी

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

आप एक fsr-सेंसर का उपयोग करके, एक स्विच पर फ़्लिप करके अपनी श्वास की तीव्रता को भी ट्रैक कर सकते हैं।

इस टोटेरियल के साथ मैं कदम दर कदम अपने खुद के रिलैक्सेशन गॉगल्स बनाने में आपका मार्गदर्शन करूंगा।

चरण 1: आवश्यक सामग्री और भाग:

सामग्री:

1x आर्डिनो ऊनो;

1xब्रेडबोर्ड या पीसीवी;

3x 10k प्रतिरोधक

तार (अधिमानतः अलग-अलग रंग इसलिए यह बताना आसान है कि कौन सी चीजें जमीन पर जा रही हैं और कौन सी अलग-अलग पिनों पर जा रही हैं, आदि);

कुछ गर्मी सिकुड़ने वाली ट्यूब;

2x NeoPixel रिंग - 16 x 5050 RGB LED इंटीग्रेटेड ड्राइवर्स के साथ;

1 एक्स स्विच;

1 एक्स एफएसआर सेंसर;

1x स्टीमपंक गॉगल्स (आप इन्हें पार्टी की दुकान पर खरीद सकते हैं, इनका उपयोग करना आसान है क्योंकि नियोपिक्सल रिंग चश्मे पर पूरी तरह से फिट बैठता है। आप हमेशा अन्य गॉगल्स का उपयोग करने की कोशिश करते हैं या अपना खुद का बनाते हैं।);

अपनी छाती के चारों ओर लगाने के लिए 1x किसी प्रकार का (इलास्टिक) बैंड।

उपकरण:-लैपटॉप

-सोल्डरिंग आयरन

-अरुडिनो आईडीई सॉफ्टवेयर

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

यहाँ नीचे आप मेरे द्वारा उपयोग की जाने वाली हर चीज़ की तस्वीरें देखेंगे:

चरण 2: नियोपिक्सल के छल्ले

सफेद तार नियोपिक्सल रिंग के पीछे जमीन से जुड़ा होता है।

नारंगी तार 5V से जुड़ा है।

और ब्राउन वायर डेटा इनपुट से जुड़ा होता है

चरण 3: कनेक्शन

प्रोटोटाइप करते समय मेरा ब्रेडबोर्ड ऐसा दिखता था, आप इसे संदर्भ के रूप में उपयोग कर सकते हैं।

मैंने केवल एक बटन के साथ जो दिखना चाहिए, उसकी वायरिंग का एक लेआउट भी बनाया।

चरण 4: कोड:

यह शायद सबसे कुशल कोड नहीं है, लेकिन यह मेरे लिए काम करता है। अपने आप को चुनौती दें और इसे और अधिक कुशल बनाने का प्रयास करें; पी

#शामिल

// कौन

Arduino पर पिन NeoPixels से जुड़ा है?

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

पिन 6

// कौन

Arduino पर पिन बटन से जुड़ा है

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

BUTTON_पिन 9

// कैसे

कई NeoPixels Arduino से जुड़े हुए हैं?

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

अंक 16

// कब

हम NeoPixel लाइब्रेरी को सेटअप करते हैं, हम यह बताते हैं कि सिग्नल भेजने के लिए कितने पिक्सेल और किस पिन का उपयोग करना है।

// ध्यान दें

कि पुराने NeoPixel स्ट्रिप्स के लिए आपको तीसरे पैरामीटर को बदलने की आवश्यकता हो सकती है - स्ट्रैंडटेस्ट देखें

//

संभावित मूल्यों के बारे में अधिक जानकारी के लिए उदाहरण।

Adafruit_NeoPixel

पिक्सेल = Adafruit_NeoPixel (NUMPIXELS, पिन, NEO_GRB + NEO_KHZ800);

अंतर विराम

= 1; // देरी2

NS

विराम २ = ८०; // नीचे जा रहा है जब fsr का उपयोग किया जा रहा है

NS

विराम3 = १५०; // जब fsr का उपयोग किया जा रहा हो तब करना

NS

देरीवल = 4; // देरी1

NS

एफएसआरपिन = 0; // FSR और 10K पुलडाउन a0. से जुड़े हैं

NS

एफएसआरपठन;

शून्य

सेट अप() {

पिनमोड (बटन_पिन, इनपुट);

सीरियल.बेगिन (९६००);

पिक्सल। शुरू (); // यह प्रारंभ करता है

नियोपिक्सल लाइब्रेरी।

पिक्सल.शो ();

}

बूल

बटन दबाया (इंट पिन) {

वापसी digitalRead (पिन);

}

शून्य

लूप () {//पढ़ता है कि पिन इनपुट सही है या गलत

fsrReading = एनालॉगरेड (fsrPin);

सीरियल.प्रिंट ("एनालॉग रीडिंग =");

सीरियल.प्रिंट (fsrReading);

अगर (बटन दबाया गया (बटन_पिन) == सत्य) {

// एफएसआर सेंसर का उपयोग करते समय प्रकाश प्रभाव

अगर (एफएसआर रीडिंग> 50) {

पिक्सल.सेटपिक्सेलकलर (0, 1, 0, 1);

पिक्सल.सेटपिक्सेलकलर(१५, १, ०, १);

पिक्सल.सेटपिक्सेलकलर(1, 1, 0, 1);

पिक्सल.सेटपिक्सेलकलर(14, 1, 0, 1);

पिक्सल.शो ();

देरी (विराम 3);

}

अगर (fsrReading <52){

पिक्सल.सेटपिक्सेलकलर (0, 0, 0, 0);

पिक्सल.सेटपिक्सेलकलर(१५, ०, ०, ०);

पिक्सल.सेटपिक्सेलकलर(1, 0, 0, 0);

पिक्सल.सेटपिक्सेलकलर (14, 0, 0, 0);

पिक्सल.शो ();

देरी (विराम 2);

}

अगर (fsrReading > 57){

पिक्सल.सेटपिक्सेलकलर(2, 1, 0, 1);

पिक्सल.सेटपिक्सेलकलर (13, 1, 0, 1);

पिक्सल.सेटपिक्सेलकलर(3, 1, 0, 1);

पिक्सल.सेटपिक्सेलकलर(१२, १, ०, १);

पिक्सल.शो ();

देरी (विराम 3);

}

अगर (एफएसआर रीडिंग <59){

पिक्सल.सेटपिक्सेलकलर(2, 0, 0, 0);

पिक्सल.सेटपिक्सेलकलर (13, 0, 0, 0);

पिक्सल.सेटपिक्सेलकलर(3, 0, 0, 0);

पिक्सल.सेटपिक्सेलकलर(१२, ०, ०, ०);

पिक्सल.शो ();

देरी (विराम 2);

}

अगर (fsrReading> 65){

पिक्सल.सेटपिक्सेलकलर (4, 1, 0, 1);

पिक्सल.सेटपिक्सेलकलर (11, 1, 0, 1);

पिक्सल.सेटपिक्सेलकलर(५, १, ०, १);

पिक्सल.सेटपिक्सेलकलर(१०, १, ०, १);

पिक्सल.शो ();

देरी (विराम 3);

}

अगर (एफएसआर रीडिंग <67){

पिक्सल.सेटपिक्सेलकलर(4, 0, 0, 0);

पिक्सल.सेटपिक्सेलकलर (११, ०, ०, ०);

पिक्सल.सेटपिक्सेलकलर(५, ०, ०, ०);

पिक्सल.सेटपिक्सेलकलर(१०, ०, ०, ०);

पिक्सल.शो ();

देरी (40);

}

अगर (एफएसआर रीडिंग> 79) {

पिक्सल.सेटपिक्सेलकलर (6, 1, 0, 1);

पिक्सल.सेटपिक्सेलकलर (९, १, ०, १);

पिक्सेल.सेट पिक्सेल रंग (7, 1, 0, 1);

पिक्सल.सेटपिक्सेलकलर (8, 1, 0, 1);

पिक्सल.शो ();

देरी (विराम 3);

}

अगर (fsrReading <85){

पिक्सल.सेटपिक्सेलकलर (6, 0, 0, 0);

पिक्सल.सेटपिक्सेलकलर (९, ०, ०, ०);

पिक्सल.सेटपिक्सेलकलर (7, 0, 0, 0);

पिक्सल.सेटपिक्सेलकलर (8, 0, 0, 0);

पिक्सल.शो ();

देरी(20);

}

}

अन्यथा{

ब्रीथ_ब्लू (20, 100, 0, 1, 1); // सामान्य

प्रभाव

}

}

// रोकें

= संक्रमण के बीच देरी

// कदम

= चरणों की संख्या

// आर, जी, बी = पूर्ण आरजीबी मूल्यों पर

// डी वॉयड ब्रीद इज वूर हेट लिच्ट इफेक्ट अल डी

fsrsensor नीट गेब्रिक्ट वर्ड्ट। डीज़ वॉयड वर्ड्ट इन डे वॉयड लूप () वेर एंगरोपेन।

शून्य ब्रीद_ब्लू (इंट पॉज़, इंट स्टेप्स, बाइट आर, बाइट जी, बाइट बी) {

NS

टीएमपीआर, टीएमपीजी, टीएमपीबी; // अस्थायी मान

// धुंधला हो जाना

के लिए (int s=1; s<=कदम; s++) {

tmpR = (आर * एस) /

कदम; // ट्रंकेशन त्रुटियों से बचने के लिए पहले गुणा करें

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0;

मैंपिक्सल.सेटपिक्सेलकलर (0, टीएमपीआर, टीएमपीजी+1, टीएमपीबी);

पिक्सल.सेटपिक्सेलकलर(15, टीएमपीआर, टीएमपीजी+1, टीएमपीबी);

}

पिक्सल.शो ();

देरी(४);

}

// धुंधला हो जाना

के लिए (int s=1; s<=कदम; s++) {

tmpR = (आर * एस) /

कदम; // ट्रंकेशन त्रुटियों से बचने के लिए पहले गुणा करें

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0;

मैंpixel.setPixelColor(1, tmpR, tmpG+1, tmpB);pixel.setPixelColor(14, tmpR, tmpG+1, tmpB);

}

पिक्सल.शो ();

देरी(४);

}

// धुंधला हो जाना

के लिए (int s=1; s<=कदम; s++) {

tmpR = (आर * एस) /

कदम; // ट्रंकेशन त्रुटियों से बचने के लिए पहले गुणा करें

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0;

मैंpixel.setPixelColor(2, tmpR, tmpG+2, tmpB);पिक्सल.सेटपिक्सेलकलर (13, टीएमपीआर, टीएमपीजी+2, टीएमपीबी);

}

पिक्सल.शो ();

देरी (3.5);

}

// धुंधला हो जाना

के लिए (int s=1; s<=कदम; s++) {

tmpR = (आर * एस) /

कदम; // ट्रंकेशन त्रुटियों से बचने के लिए पहले गुणा करें

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0;

मैंपिक्सल.सेटपिक्सेलकलर(3, tmpR, tmpG+3, tmpB+5);पिक्सल.सेटपिक्सेलकलर(12, टीएमपीआर, टीएमपीजी+3, टीएमपीबी+5);

}

पिक्सल.शो ();

देरी(3);

}

के लिए (int i=0;

मैंपिक्सल.सेटपिक्सेलकलर (0, 0, 0, 0);पिक्सल.सेटपिक्सेलकलर(१५, ०, ०, ०);

}

// धुंधला हो जाना

के लिए (int s=1; s<=कदम; s++) {

tmpR = (आर * एस) /

कदम; // ट्रंकेशन त्रुटियों से बचने के लिए पहले गुणा करें

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0;

मैं

पिक्सल.सेटपिक्सेलकलर (4, टीएमपीआर, टीएमपीजी+3, टीएमपीबी+15);पिक्सल.सेटपिक्सेलकलर (11, टीएमपीआर, टीएमपीजी+3, टीएमपीबी+15);

}

पिक्सल.शो ();

देरी(3);

}

// धुंधला हो जाना

के लिए (int s=1; s<=कदम; s++) {

tmpR = (आर * एस) /

कदम; // ट्रंकेशन त्रुटियों से बचने के लिए पहले गुणा करें

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0;

मैंपिक्सल.सेटपिक्सेलकलर(5, टीएमपीआर, टीएमपीजी+4, टीएमपीबी+20);पिक्सल.सेटपिक्सेलकलर(10, टीएमपीआर, टीएमपीजी+4, टीएमपीबी+20);

}

पिक्सल.शो ();

देरी(2);

}

के लिए (int i=0;

मैंपिक्सल.सेटपिक्सेलकलर(1, 0, 0, 0);

पिक्सल.सेटपिक्सेलकलर (14, 0, 0, 0);

}

// धुंधला हो जाना

के लिए (int s=1; s<=कदम; s++) {

tmpR = (आर * एस) /

कदम; // ट्रंकेशन त्रुटियों से बचने के लिए पहले गुणा करें

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0;

मैंपिक्सल.सेटपिक्सेलकलर (6, टीएमपीआर, टीएमपीजी+2, टीएमपीबी+40);

पिक्सल.सेटपिक्सेलकलर (9, टीएमपीआर, टीएमपीजी+2, टीएमपीबी+40);

}

पिक्सल.शो ();

देरी (देरी);

}

के लिए (int i=0;

मैंपिक्सल.सेटपिक्सेलकलर(2, 0, 0, 0);पिक्सल.सेटपिक्सेलकलर (13, 0, 0, 0);

}

// धुंधला हो जाना

के लिए (int s=1; s<=कदम; s++) {

tmpR = (आर * एस) /

कदम; // ट्रंकेशन त्रुटियों से बचने के लिए पहले गुणा करें

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0;

मैं

पिक्सल.सेटपिक्सेलकलर (7, टीएमपीआर, टीएमपीजी, टीएमपीबी+44);पिक्सल.सेटपिक्सेलकलर (8, टीएमपीआर, टीएमपीजी, टीएमपीबी+44);

}

पिक्सल.शो ();

देरी (देरी);

}

// फीका पड़ना

के लिए (int s=steps; s>0; s--) {

tmpR = (आर * एस) / कदम; // छंटनी से बचने के लिए पहले गुणा करें

त्रुटियों

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0; i

पिक्सल.सेटपिक्सेलकलर (7, टीएमपीआर, टीएमपीजी, टीएमपीबी);

पिक्सल.सेटपिक्सेलकलर (8, टीएमपीआर, टीएमपीजी, टीएमपीबी);

}

पिक्सल.शो ();

देरी(1);

}

// फीका पड़ना

के लिए (int s=steps; s>0; s--) {

tmpR = (आर * एस) / कदम; // छंटनी से बचने के लिए पहले गुणा करें

त्रुटियों

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0; i

पिक्सल.सेटपिक्सेलकलर (6, टीएमपीआर, टीएमपीजी, टीएमपीबी);

पिक्सल.सेटपिक्सेलकलर (9, टीएमपीआर, टीएमपीजी, टीएमपीबी);

}

पिक्सल.शो ();

देरी(1);

}

// फीका पड़ना

के लिए (int s=steps; s>0; s--) {

tmpR = (आर * एस) / कदम; // छंटनी से बचने के लिए पहले गुणा करें

त्रुटियों

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0; i

पिक्सल.सेटपिक्सेलकलर (5, टीएमपीआर, टीएमपीजी, टीएमपीबी);

पिक्सल.सेटपिक्सेलकलर (10, टीएमपीआर, टीएमपीजी, टीएमपीबी);

}

पिक्सल.शो ();

देरी(2);

}

// फीका पड़ना

के लिए (int s=steps; s>0; s--) {

tmpR = (आर * एस) / कदम; // छंटनी से बचने के लिए पहले गुणा करें

त्रुटियों

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0; i

पिक्सल.सेटपिक्सेलकलर (4, टीएमपीआर, टीएमपीजी, टीएमपीबी);

पिक्सल.सेटपिक्सेलकलर (11, टीएमपीआर, टीएमपीजी, टीएमपीबी);

}

पिक्सल.शो ();

देरी(2);

}

// फीका पड़ना

के लिए (int s=steps; s>0; s--) {

tmpR = (आर * एस) / कदम; // छंटनी से बचने के लिए पहले गुणा करें

त्रुटियों

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0; i

पिक्सल.सेटपिक्सेलकलर(3, tmpR, tmpG, tmpB);

पिक्सल.सेटपिक्सेलकलर(12, टीएमपीआर, टीएमपीजी, टीएमपीबी);

}

पिक्सल.शो ();

देरी(3);

}

// फीका पड़ना

के लिए (int s=steps; s>0; s--) {

tmpR = (आर * एस) / कदम; //

ट्रंकेशन त्रुटियों से बचने के लिए पहले गुणा करें

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0; i

pixel.setPixelColor(2, tmpR, tmpG, tmpB);

पिक्सल.सेटपिक्सेलकलर (13, टीएमपीआर, टीएमपीजी, टीएमपीबी);

}

पिक्सल.शो ();

देरी(3);

}

// फीका पड़ना

के लिए (int s=steps; s>0; s--) {

tmpR = (आर * एस) / कदम; // छंटनी से बचने के लिए पहले गुणा करें

त्रुटियों

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0; i

pixel.setPixelColor(1, tmpR, tmpG, tmpB);

पिक्सल.सेटपिक्सेलकलर (14, टीएमपीआर, टीएमपीजी, टीएमपीबी);

}

पिक्सल.शो ();

देरी(४);

}

// फीका पड़ना

के लिए (int s=steps; s>0; s--) {

tmpR = (आर * एस) / कदम; // छंटनी से बचने के लिए पहले गुणा करें

त्रुटियों

टीएमपीजी = (जी * एस) / कदम;

टीएमपीबी = (बी * एस) / कदम;

के लिए (int i=0; i

पिक्सल.सेटपिक्सेलकलर (0, टीएमपीआर, टीएमपीजी, टीएमपीबी);

पिक्सल.सेटपिक्सेलकलर(15, टीएमपीआर, टीएमपीजी, टीएमपीबी);

}

पिक्सल.शो ();

देरी(४);

}

}

चरण 5: सब कुछ एक साथ रखना:

आप अपने ब्रेडबोर्ड या पीवीसी से जुड़े अपने सभी तारों को छोड़ सकते हैं, जो आपके ऊपर है (मैंने Arduino के ऊपर एक पीवीसी लगाने के लिए चुना है यह उस तरह से अच्छा और साफ है)।

अगला कदम सभी तारों के चारों ओर हीट सिकुड़ने वाली ट्यूब लगाना है ताकि यह गड़बड़ न हो।

यदि आपने पीवीसी का उपयोग करना चुना है तो आपको अब तक सब कुछ एक साथ मिला देना चाहिए था।

उसके बाद आप चश्मे के बाहर नियोपिक्सल के छल्ले लगाते हैं (सुनिश्चित करें कि एलईडी बटम पर संरेखित हैं) और उन्हें कुछ टेप या गोंद (मैंने टेप का इस्तेमाल किया) के साथ सुरक्षित करें।

आप fsr-sensor को कुछ टेप के साथ इलास्टिक बैंड से चिपकाना चुन सकते हैं या इसे अपने आप छोड़ सकते हैं।

अपने चश्मे का आनंद लें:)