बुनियादी Arduino प्रोग्रामिंग सीखना - नवागंतुकों के लिए ट्यूटोरियल

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

परिचय

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

एक उपयोगकर्ता के लिए एक माइक्रोकंट्रोलर इतना उपयोगी हो जाता है क्योंकि यह एक अंतर्निहित प्रोसेसर, मेमोरी और इनपुट / आउटपुट पोर्ट (जिसे GPIO या सामान्य प्रयोजन इनपुट / आउटपुट पिंस भी कहा जाता है) प्रदान करता है जिसे हम उपयोगकर्ता द्वारा किसी भी वांछित विनिर्देशों के अनुसार नियंत्रित किया जा सकता है।

इस ट्यूटोरियल में हम कार्यक्रमों को सीखने और परीक्षण के लिए एक Arduino Uno बोर्ड के साथ काम करेंगे। हार्डवेयर असेंबली के परीक्षण और एकीकरण के लिए हम एक ब्रेडबोर्ड का उपयोग करेंगे।

अब चलो जल्दी से चलते हैं और सीखते हैं कि कैसे एक Arduino प्रोग्रामिंग के साथ शुरुआत करें।

1.2 सॉफ्टवेयर स्थापित करना (विंडोज)

इसके लिए आपको इंटरनेट तक पहुंच की आवश्यकता होगी, जो स्पष्ट रूप से आपके कंप्यूटर में होगा। कृपया निम्न लिंक पर जाएं और IDE सॉफ्टवेयर डाउनलोड करें:

नॉन एडमिन इंस्टॉल के लिए विंडोज जिप फाइल

डाउनलोड करने के बाद आपको डाउनलोड फ़ोल्डर में Arduino सेटअप आइकन मिलेगा, जो इस तरह दिखेगा:

एक बार जब आप इसे प्राप्त कर लेते हैं, तो आप बस इस पर डबल क्लिक कर सकते हैं और अपने कंप्यूटर में Arduino को एकीकृत विकास पर्यावरण (IDE) स्थापित कर सकते हैं। पूरी प्रक्रिया को निम्नलिखित वीडियो में देखा जा सकता है:

1.4 हमारे पहले सर्किट के साथ शुरू

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

जैसा कि हम जानते हैं कि एक एलईडी एक प्रकाश उत्सर्जक डायोड है जिसमें एक ध्रुवीयता होती है और अगर यह सही आपूर्ति के खंभे से जुड़ा नहीं है, तो रोशन नहीं होगा।

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

अंगूठे के एक नियम के रूप में, एक आवश्यक सुरक्षित स्तर तक वर्तमान को सीमित करने के लिए आपूर्ति इनपुट में प्रत्येक 5V वृद्धि के लिए 330 ओम 1/4 वाट काफी आदर्श है। इसलिए 5 वी के लिए यह 330 ओम हो सकता है, 10 वी के लिए यह 680 ओम और इतने पर हो सकता है।

विधानसभा के लिए ब्रेडबोर्ड का उपयोग करना

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

मूल एलईडी कनेक्शन सेटअप को नीचे देखा जा सकता है:

आप ऊपर 3 बुनियादी घटक देख सकते हैं:

1. एक 5 मिमी, 20mA एलईडी
2. एक 330 ओम 1/4 वाट रोकनेवाला
3. एक Arduino बोर्ड

बस आरेख के अनुसार सिस्टम को इकट्ठा करें।

अगला, कंप्यूटर USB से Arduino में 5V में प्लग करें। जैसे ही आप ऐसा करते हैं आप एलईडी प्रकाश व्यवस्था देखेंगे।

मुझे पता है कि यह बहुत बुनियादी है, लेकिन खरोंच से शुरू करना हमेशा अच्छा होता है। जैसे ही हम आगे बढ़ेंगे बाकी सुनिश्चित चीजें अधिक से अधिक दिलचस्प होने लगेंगी।

1.5 Arduino के साथ एलईडी नियंत्रण

अब हम सीखेंगे कि एक Arduino प्रोग्राम के साथ एक एलईडी को कैसे नियंत्रित किया जाए।

एक कार्यक्रम लिखने के लिए हमारे पास प्रत्येक कार्यक्रम में कम से कम 2 कार्य होने चाहिए।

एक फ़ंक्शन को प्रोग्रामिंग स्टेटमेंट्स की एक श्रृंखला के रूप में समझा जा सकता है जिसे एक नाम के साथ सौंपा जा सकता है, जैसा कि नीचे दिया गया है:

1. सेट अप() इसे प्रोग्राम की शुरुआत के दौरान कहा जाता है या निष्पादित किया जाता है।
2. पाश () इसे Arduino के पूरे परिचालन काल के दौरान दोहराव से बुलाया या निष्पादित किया जाता है।

इसलिए, हालांकि इसकी कोई व्यावहारिक कार्यक्षमता नहीं हो सकती है, तकनीकी रूप से सबसे कम वैध Arduino कार्यक्रम के रूप में लिखा जा सकता है:

सरलतम कार्यक्रम

void setup()
{
}
void loop()
{
}

आपने देखा होगा कि कई प्रोग्रामिंग भाषाओं में, डिस्प्ले स्क्रीन पर एक साधारण प्रिंट, 'हैलो, वर्ल्ड' दिखा कर सिस्टम शुरू होता है।

माइक्रोकंट्रोलर व्याख्या में इस वाक्यांश के लिए इलेक्ट्रॉनिक समतुल्य एक एलईडी पर और बंद झपकी है।

यह सबसे बुनियादी कार्यक्रम है जो सिस्टम के एक सही कामकाज को इंगित करने के लिए लिख और लागू कर सकता है।

हम निम्नलिखित कोड के माध्यम से प्रक्रिया को लागू करने और समझने की कोशिश करेंगे:

लिस्टिंग 1.2: led1 / led1.pde

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

ठीक है, अब समझते हैं कि कोड की प्रत्येक पंक्ति का क्या अर्थ है और यह फ़ंक्शन को निष्पादित करने के लिए कैसे काम करता है:

const int kPinLed = 13

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

मानक नियमों के अनुसार ऐसे स्थिरांक को शुरुआती अक्षर से पहचाना जाता है सेवा मेरे । हालांकि यह अनिवार्य नहीं है, यह चीजों को तब भी स्पष्ट और आसानी से समझा जा सकता है जब भी आपको कोड विवरण के माध्यम से जाने का मन करता है।

void setup()
{
pinMode(kPinLed, OUTPUT)
}

यह कोड उस विशिष्ट पिन को कॉन्फ़िगर करता है, जिस पर हमारी एलईडी को हुक किया जाता है। दूसरे शब्दों में, कोड 'पढ़ने' के बजाय इस पिन पर 'लेखन' पहलू को नियंत्रित करने के लिए Arduino को बताता है।

void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

उपरोक्त पंक्तियाँ आवेदन के वास्तविक निष्पादन का संकेत देती हैं। यह कोड एलईडी को चालू करते हुए, संबंधित एलईडी कनेक्शन पर एक उच्च को लिख और रेंडर करके शुरू होता है।

यहाँ, उच्च शब्द का सीधा अर्थ है Arduino के संबंधित पिन पर + 5V प्राप्त करना। पूरक शब्द LOW केवल निर्दिष्ट पिन पर एक शून्य या 0V इंगित करता है।

अगला, हम कहते हैं delay() जिसका कार्य मिलीसेकंड (एक सेकंड के 1/1000 वें) के माध्यम से देरी पैदा करना है। चूंकि आंकड़ा 500 दर्ज किया गया है, इसलिए कार्यान्वित विलंब 1/2 सेकंड के लिए होने वाला है।

जैसे ही यह 1/2 सेकंड व्यतीत हो जाता है, अगली पंक्ति को निष्पादित किया जाता है जो उसी पिन पर LOW पद के साथ LED OFF को चालू करता है।

बाद की पंक्ति अभी भी 1/2 सेकंड विलंब उत्पन्न करती है, जिससे एलईडी को 1/2 सेकंड के लिए बंद रहने की अनुमति मिलती है।

और कोड की पंक्तियों के निष्पादन से प्रक्रिया असीम रूप से जारी रहती है, जब तक कि अरुडिनो को संचालित रखा जाता है।

अगले स्तर पर आगे बढ़ने से पहले, मैं आपको उपरोक्त कोड को प्रोग्राम करने और यह जांचने की सलाह दूंगा कि क्या आप LED ON / OF अनुक्रम को सही ढंग से कार्यान्वित करने में सक्षम हैं या नहीं।

चूंकि अरुडिनो में डिफ़ॉल्ट एलईडी पिन # 13 के साथ जुड़ा हुआ है, इसलिए इसे तुरंत उपरोक्त कार्यक्रम पर प्रतिक्रिया देनी चाहिए और फ्लैश करना शुरू करना चाहिए। हालाँकि, यदि आप अपने बाहरी एलईडी को चमकती नहीं पाते हैं, तो आपके एलईडी के साथ एक कनेक्शन दोष हो सकता है, आप अपने एलईडी की ध्रुवीयता को उलटने की कोशिश कर सकते हैं और उम्मीद है कि यह पलक भी झपकाएगा।

आप विलंब समय के साथ '500' के आंकड़े को किसी अन्य मूल्य में बदलकर खेल सकते हैं और कमांड के लिए एलईडी 'सुनने' को ढूंढ सकते हैं और इसके कारण निर्दिष्ट विलंब मानों के अनुसार फ्लैश कर सकते हैं।

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

1.7 टिप्पणियाँ

कोड की पंक्तियाँ जिन्हें हम ऊपर समझ रहे थे, विशेष रूप से कंप्यूटर सॉफ्टवेयर के लिए लिखे गए थे।

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

इन्हें कहा जाता है टिप्पणियाँ जो केवल मानव या उपयोगकर्ता संदर्भ के लिए लिखे गए हैं, और उन्हें सुरक्षित रूप से अनदेखा करने के लिए कंप्यूटर को सक्षम करने के लिए कोडित किया गया है।

इन टिप्पणियों की भाषा कुछ स्वरूपों के साथ लिखी गई है:

1. टिप्पणी की ब्लॉक शैली, जिसमें टिप्पणी विवरण प्रारंभ प्रतीक / * और समाप्ति प्रतीक * * के तहत संलग्न है
2. इसे एक पंक्ति में प्रतिबंधित करने की आवश्यकता नहीं है, बल्कि टिप्पणी या विवरण की लंबाई के आधार पर अगले बाद की लाइनों तक बढ़ाया जा सकता है, जैसा कि निम्नलिखित उदाहरण में दिखाया गया है:

/ * यह एक टिप्पणी है * /

/ * तो यह है * /

/* तथा
* इस
* जैसा
* कुंआ */

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

// यह एक टिप्पणी है जिसे कंप्यूटर अनदेखा करेगा।

यहाँ संदर्भ के लिए एक उदाहरण है:

/*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/

/* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}

१.hooting समस्या निवारण

यदि आपको अपना कार्यक्रम संकलन करते समय, या किसी अन्य मुद्दे पर एक 'त्रुटि' दिखा रहा है, तो निम्नलिखित युक्तियां संभवतः आपके कोड को बाधा से छुटकारा पाने में मदद करेंगी।

1. आपकी प्रोग्राम लैंग्वेज केस सेंसिटिव होगी। उदाहरण के लिए अभिव्यक्ति MyVar के रूप में नहीं लिखा जा सकता है MyVar।
2. सभी प्रकार के सफेद स्थान जो आपके कीबोर्ड टाइपिंग द्वारा निष्पादित किए जा सकते हैं, अंततः एक ही स्थान के रूप में प्रस्तुत किए जाते हैं, और यह केवल आपके द्वारा दिखाई या समझा जाता है, कंप्यूटर इसे ध्यान में नहीं रखेगा। सीधे शब्दों में कहें, किसी भी तरह के खाली स्थानों का कोड परिणामों पर कोई प्रभाव नहीं पड़ेगा।
3. कोड के प्रत्येक ब्लॉक को बाएं और दाएं घुंघराले कोष्ठक के साथ संलग्न किया जाना चाहिए, '{' तथा '}'
4. संख्या अंकों को अल्पविराम से अलग नहीं किया जाना चाहिए। उदाहरण के लिए, 1000 को 1000 के रूप में नहीं लिखा जा सकता है।
5. घुंघराले कोष्ठक के बीच संलग्न प्रत्येक कोड रेखा अर्धविराम के साथ समाप्त होनी चाहिए

अरुडिनो के साथ दिलचस्प एलईडी लाइट सीक्वेंस बनाना

हमारे पिछले अध्याय में हमने सीखा कि लगातार देरी दर के साथ एक एलईडी ON / OFF को कैसे ब्लिंक किया जाए।

अब हम सीखेंगे कि प्रोग्राम कोड को अपग्रेड करके एक ही एलईडी पर विभिन्न विलंब पैटर्न कैसे निष्पादित किए जा सकते हैं।

हम बाहरी एलईडी का उपयोग नहीं करेंगे, बल्कि पिन # 13 पर Arduino बोर्ड में निर्मित डिफ़ॉल्ट एलईडी का उपयोग करेंगे। आप इस छोटे SMD LED को USB कनेक्टर के ठीक पीछे पा सकते हैं।

2.2 यदि आईएफए को समझना

इस खंड में हम सीखेंगे कि कैसे नियंत्रण संरचनाएं हमें अलग-अलग कोड चलाने में सक्षम बनाती हैं, और कभी-कभी आवश्यकता के अनुसार दोहराव से भी।

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

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

हम उपरोक्त कोड को चरण-वार समझने की कोशिश करेंगे और सीखेंगे कि इसका उपयोग अन्य समान निष्पादन के लिए कैसे किया जा सकता है।

पहली और 7 वीं पंक्ति के बीच कोड हमारे शुरुआती कार्यक्रम के समान हैं।

पहला संशोधन वास्तव में 8 वीं पंक्ति पर होता है।

int delayTime = 1000

आप इसे 1 लाइन पर कोड के समान हो सकते हैं, इस तथ्य को छोड़कर कि यह शब्द गायब है कॉन्स्ट।

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

उपर्युक्त उदाहरण में आप देख सकते हैं कि इस चर को 1000 के मान के साथ जिम्मेदार ठहराया गया है। याद रखें, ऐसे चर जिन्हें घुंघराले कोष्ठक के भीतर संलग्न किया गया है, उन्हें केवल घुंघराले कोष्ठक के जोड़े में कड़ाई से लिखा जाना है, और उन्हें 'स्थानीय' चर के रूप में जाना जाता है।

वैकल्पिक रूप से, चर जो कि घुंघराले कोष्ठक के बाहर होने वाले हैं, जैसे कि अब हम जिस पर चर्चा कर रहे हैं उसे 'वैश्विक' के रूप में मान्यता प्राप्त है, और इसे प्रोग्राम कोड के भीतर कहीं भी निष्पादित किया जा सकता है।

आगे बढ़ते हुए, आप देख सकते हैं कि लाइन 9 और 11 के बीच कोड भी पहले कार्यक्रम के समान हैं, फिर भी लाइन 11 के बाद दिलचस्प चीजें शुरू होती हैं। आइए देखें कि कैसे!

delayTime = delayTime - 100

इस कोड में हम देखते हैं कि का डिफ़ॉल्ट मान विलम्ब इसमें से 100 घटाकर संशोधित किया जा रहा है।

मतलब 100 को उसके 1000 के शुरुआती मूल्य से घटा दिया गया है, जो उसे 900 का नया मूल्य प्रदान करता है।

निम्नलिखित छवि के माध्यम से हम Arduino भाषा में उपयोग किए गए कुछ मठ संचालकों को समझने की कोशिश करेंगे।

अब आइए रेखा १३ १५ के बीच के कोडों का आकलन करें।

if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}

कोड के उपरोक्त टुकड़े का मुख्य उद्देश्य यह सुनिश्चित करना है कि एलईडी बिना किसी रुकावट के पलक झपकते रहे।

इस तथ्य के कारण कि मूल से 100 काटा जा रहा है विलम्ब , यह एलईडी ब्लिंकिंग को शून्य तक पहुंचने से रोकता है और ब्लिंकिंग को लगातार चलने देता है।

निम्नलिखित छवि कुछ तुलना ऑपरेटरों को दिखाती है जिन्हें हम अपने कोड में उपयोग करेंगे:

हमारे उपरोक्त कोड में, हम कोड का परीक्षण कर सकते थे। _ + _ |

हालांकि, क्योंकि नकारात्मक आंकड़ा समान रूप से खराब हो सकता है, हम इसके लिए नहीं गए, और यह एक अनुशंसित अभ्यास है।

सोचिए अगर हम 100 के बजाय 300 घटाने की कोशिश करते तो परिणाम क्या हो सकते थे? _ + _ |

तो अब आप समझ गए होंगे कि अगर if(delayTime == 0) शून्य के बराबर या उससे कम लिखा जाता है, फिर विलंब का समय मूल आकृति 1000 पर वापस आ जाएगा।

delayTime

ऊपर दिखाए गए अनुसार कोड की अंतिम 4 पंक्तियाँ लगातार, चालू / बंद एलईडी चालू करने के लिए जिम्मेदार बन जाती हैं।

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

2.3 ELSE कथन

यहां हम जानेंगे कि क्यों और कैसे ए अगर पद का एक खंड हो सकता है अन्य ताकि यह मामले में स्थिति तय करे अगर बयान गलत है।

मुझे खेद है कि अगर यह बहुत भ्रामक लगता है, तो चिंता न करें, हम इसे निम्नलिखित उदाहरण से समझने की कोशिश करेंगे:

delayTime

ऊपर आप अच्छी तरह से देख सकते हैं कि 10 वीं पंक्ति में कोड केवल तभी निष्पादित किया जाता है जब | _ _ + _ | 100 से कम या बराबर है, यदि नहीं तो 13 वीं पंक्ति में कोड निष्पादित किया जाता है, लेकिन दोनों एक साथ कभी नहीं हो सकते हैं, या तो 10 वीं पंक्ति या 13 वीं पंक्ति कोड लागू किया जाएगा, दोनों कभी नहीं।

आपने देखा होगा कि हमने अपने पिछले खंड 2.2 में जो किया था, उसके विपरीत, यहाँ हमने 0 की तुलना नहीं की, बल्कि 100 के साथ तुलना की। ऐसा इसलिए है क्योंकि इस उदाहरण की तुलना में हमने 100 को घटाया, खंड 2.2 में, हमने इसकी तुलना की। घटाया हुआ। क्या आप बता सकते हैं कि अगर हम 100 की बजाय 0 की तुलना में होते तो क्या हो सकता था?

2.4 कथन जारी करें

सेवा मेरे जबकि कथन काफी हद तक समान है अगर कथन को छोड़कर, यह सच है कि यह कोड के एक ब्लॉक (जो घुंघराले कोष्ठक के बीच हो सकता है) के लिए बार-बार निष्पादन का कारण बनता है, जब तक कि शर्तें लागू हों, और यह बिना काम करता है अन्य बयान।

निम्नलिखित उदाहरण आपको इसे बेहतर ढंग से समझने में मदद करेंगे

digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)

क्या आप अनुमान लगा सकते हैं कि उपरोक्त कोड क्या करने के लिए प्रोग्राम किया गया है? खैर, यह तेजी से एलईडी को ब्लिंक करने के लिए डिज़ाइन किया गया है और फिर धीमी है।

२.५ सत्य और असत्य क्या है?

प्रोग्रामिंग भाषा में, असत्य शून्य (0) को संदर्भित करता है। वास्तव में 'सत्य' का उपयोग नहीं किया जाता है, इसके बजाय यह माना जाता है कि जब कुछ भी गलत नहीं होता है, तो जो कुछ भी शामिल है वह सच है।

यह थोड़ा अजीब लगता है, लेकिन यह अच्छी तरह से काम करता है।

हम निम्नलिखित उदाहरण के माध्यम से स्थिति को समझने की कोशिश करेंगे।

आप कभी-कभी नीचे दिए गए कोड के अनुसार आ सकते हैं:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

यह कोडित दिखता है जैसे एलईडी निष्पादन हमेशा के लिए साइकिल चलाएगा, क्योंकि लंबी शक्ति उपलब्ध है।

हालाँकि, इस प्रकार का एक कोड तब उत्पन्न हो सकता है जब उपयोगकर्ता गलती से == के बजाय = लागू करता है।

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

उदाहरण के लिए, मान लीजिए कि आपको क्रमिक रूप से तेज़ पैटर्न और दोहराव के साथ फ्लैश करने के लिए एलईडी की आवश्यकता है, लेकिन गलत तरीके से == के बजाय a = का उपयोग किया जाता है।

तब कोड इस प्रकार दिखाई देगा:

delayTime

यह गलती 0 से const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
} असाइन करेगी, और ले जाएगी अगर यह जाँचने के लिए कि क्या 0 सच था या नहीं। चूँकि 0 झूठे को संदर्भित करता है, यह सोचेगा कि यह सच नहीं है, और यह लागू नहीं होगा। _ + _ |, लेकिन इसके बजाय फ़ंक्शन while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
} लूप के दौरान 0 पर आयोजित किया जाता है ()।

यह बहुत अवांछनीय लगता है !!

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

2.6 संयोजन

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

तार्किक शब्दों पर संयोजनों को लागू करना 3 तरीकों से किया जा सकता है, जैसा कि निम्नलिखित तालिका में दिखाया गया है:

यह जानना दिलचस्प होगा कि NOT ऑपरेटर एक चर के लिए स्विचर के रूप में काम कर सकता है जिसे या तो नामित किया जा सकता है सच या असत्य (या कम या उच्च)।

निम्नलिखित उदाहरण हालत को दर्शाता है:

int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}

यहाँ | _ _ + _ | कम हो जाएगा, और बाद में जैसे ही delayTime, यह हाई हो जाएगा। निम्नलिखित लूप का कारण होगा। _ + _ | to be HIGH कब delayTime = 1000 कम है।

2.7 बयानों के लिए

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

आइए इसे निम्न उदाहरण से समझते हैं:

delayTime

आप के साथ लाइन में कुछ अनूठा पा सकते हैं लिए।

यह कोड है मैं ++? । यह उन प्रोग्रामर के लिए उपयोगी है जो आलसी हैं और सुविधाजनक शॉर्टकट के माध्यम से कोडिंग को लागू करना चाहते हैं

उपरोक्त शब्द को कंपाउंड ऑपरेटर्स के रूप में जाना जाता है, क्योंकि वे एक असाइनमेंट ऑपरेटर को दूसरे असाइनमेंट ऑपरेटर के साथ मिलाने का काम करते हैं। इनमें से सबसे लोकप्रिय को निम्न तालिका में देखा जा सकता है:

आप पाएंगे कि एक स्टेटमेंट में 3 सब-स्टेटमेंट हैं। इसे नीचे दिखाए अनुसार संरचित किया गया है:

int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}

कथन # 1 शुरुआत में और सिर्फ एक बार सही होता है। लूप के दौरान हर बार स्थिति का परीक्षण किया जाता है। जब चाहे सच घुंघराले कोष्ठक के अंदर, बाद का कथन # 2 लागू हो जाता है। मामले में ए असत्य, सिस्टम कोड के अगले ब्लॉक में कूदता है।

अधिक एलईडी कनेक्ट करना

ठीक है, अब हम देखेंगे कि अधिक रोचक प्रभाव प्राप्त करने के लिए हम अधिक संख्या में लीड्स को कैसे कनेक्ट कर सकते हैं।

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

अब एक प्रोग्राम को ठीक करते हैं जो हमें यह जांचने में सक्षम करेगा कि हमारा हार्डवेयर सही तरीके से कॉन्फ़िगर किया गया है या नहीं।

यह हमेशा यह जांचने के लिए अनुशंसित होता है कि प्रोग्राम के छोटे-छोटे बिट्स को चरणबद्ध तरीके से निष्पादित किया जाए या नहीं, यह जांचने के लिए कि संबंधित हार्डवेयर सही ढंग से वायर्ड हैं या नहीं।

यह एक संभावित त्रुटि का शीघ्र निवारण करने में मदद करता है।

नीचे दिए गए कोड का उदाहरण एलईडी 2 से 5 एक विशिष्ट पैटर्न को चक्रीय तरीके से एक के बाद एक मोड़कर प्रदान करता है।

ledState

जैसा कि आप देख सकते हैं, कोड के साथ कुछ भी गलत नहीं है, इस तथ्य को छोड़कर कि यह लंबा दिखता है और इसलिए गलतियों का खतरा है।

बेशक उपरोक्त कोड को लिखने के बेहतर तरीके हैं, निम्न अनुभाग इसे प्रकट करेगा।

2.9 एरे का परिचय

Arrays वैरिएबल का एक समूह हो सकता है जिसे इंडेक्स नंबरों के साथ अनुक्रमित किया जा सकता है। निम्नलिखित उदाहरण हमें इसे बेहतर ढंग से समझने में मदद करेंगे।

ledState = !ledState

ठीक है, अब चलो प्रत्येक अनुभाग से गुजरते हैं और समझते हैं कि वे वास्तव में कैसे काम करते हैं।

ledState

उपरोक्त कोड परिभाषित करता है कि हम कितने अधिकतम तत्वों को सरणी में रखने वाले हैं। यह कोड हमें बाद के अनुभागों में यह सुनिश्चित करने में मदद करता है कि सब कुछ किसी सरणी में लिखा गया है और सरणी समाप्त होने के बाद कुछ भी नहीं।

ledState = !ledState

इस अगली पंक्ति में हमने सरणी संरचना की स्थापना की। ब्रैकेट के अंदर की संख्या सरणी में तत्वों की संख्या को दर्शाती है। हालाँकि, वास्तविक मात्रा लिखी जा सकती थी, क्योंकि स्थिरांक बेहतर है। मानों को आम तौर पर कोमा के साथ ब्रैकेट के अंदर देखा जा सकता है और मानों को सरणी में नामित किया जा सकता है।

जब आप संख्या 0 के साथ अनुक्रमित एक सरणी पाते हैं, तो यह सरणी में पहले तत्व को इंगित करता है, जैसा कि __ + _ _ में दिखाया गया है।

इसी तरह अंतिम तत्व के रूप में दिखाया जाएगा const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}, चूंकि गिनती 0 से 3 तक 4 है।

for (statement1conditionstatement2){
// statements
}

उपरोक्त कोड प्रत्येक सरणी तत्वों के माध्यम से आगे बढ़ने के लिए और उन्हें OUTPUTS के रूप में सेट करने के लिए लूप के उपयोग को दर्शाता है। हम सरणी में प्रत्येक तत्व तक पहुंचने के लिए सूचकांक के साथ-साथ चौकोर कोष्ठक लागू करते हैं।

यदि आप सोच रहे हैं कि क्या सरणियों के बिना पिन # 2 से पिन # 5 का उपयोग करना संभव है, तो उत्तर है हां, यह संभव है। लेकिन इस उदाहरण में ऐसा नहीं किया गया है क्योंकि हमने उस तरीके से ऐसा नहीं किया। निम्न अनुभागों में आप सरणी दृष्टिकोण को समाप्त कर सकते हैं यदि चयनित आउटपुट पिन लाइन में नहीं हैं।

आगे बढ़ते हुए, देखते हैं कि कोड का अगला ब्लॉक क्या करता है:

const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}

यहां कोड प्रत्येक एलईडी के माध्यम से 100 मिलीसेकंड के अंतराल या देरी के साथ क्रमिक रूप से स्विच करने के लिए आगे बढ़ता है।

const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}
void loop()
{
for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}

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

यह से शुरू होता है const int k_numLEDs = 4 क्योंकि सरणियाँ शून्य अनुक्रमित हैं। हम शुरू नहीं करते हैं const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5 क्योंकि वह सरणी के अंत को पार करने में परिणाम होगा।

कोड> = 0 का उपयोग करता है ताकि यह जांचा जा सके कि सूचकांक 0 पर पहला तत्व याद नहीं है या अनदेखा किया गया है।

अध्याय 3

एक इनपुट क्या है

तो क्या हमें सीखा गया है कि Arduino का उपयोग करके चीजों को कैसे संचालित किया जाए। इस अध्याय में हम चर्चा करेंगे कि बाहरी मापदंडों से आदानों को इंटरफेयर करके वास्तविक दुनिया को कैसे समझें।

3.1 पुशबटन का उपयोग करना

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

3.1.1 एक बटन और एक एलईडी

हम ऊपर दिखाए गए विवरण के अनुसार Arduino को पुश-बटन के साथ Arduino से जोड़ेंगे और सेट अप के मूल कार्य और कार्यान्वयन को जानेंगे।

संकेतित पुश बटन जिसे माइक्रो स्विच पुश बटन भी कहा जाता है, इसमें कुल 4 पिन हैं (प्रत्येक पक्ष पर 2 जोड़े)। जब धक्का दिया जाता है, तो प्रत्येक जोड़ी पिन आंतरिक रूप से जुड़ जाती है और उन पर एक कनेक्शन या चालन सक्षम करती है।

इस उदाहरण में हम इन पिनों या संपर्कों में से केवल एक जोड़ी का उपयोग कर रहे हैं, दूसरी जोड़ी अप्रासंगिक है और इसलिए इसे अनदेखा किया गया है।

चलो आगे बढ़ते हुए निम्नलिखित कोड को लागू कर रहे हैं और इसे काम कर रहे हैं!

code: k_LEDPins is k_LEDPins[0]

आपको कुछ चीज़ें मिल सकती हैं जो यहाँ असामान्य लगती हैं। चलो उन्हें चरणवार समझें।

k_LEDPins[3]

पहली चीज जो हम करते हैं वह है फिक्स बटनपिन के रूप में INPUT वैसे यह काफी बुनियादी है, मुझे पता है।

अगला, हम असाइन करते हैं उच्च तक इनपुट पिन करें। आपको आश्चर्य है, इनपुट पर कुछ भी लिखना कैसे संभव हो सकता है? यकीन है, यह दिलचस्प हो सकता है।

दरअसल, एक Arduino इनपुट के लिए एक हाई को असाइन करना एक आंतरिक 20k ओहम पुल-अप रेसिस्टर्स को चालू करता है (इस पिन पर एक कम इसे बंद होता है)।

एक और सवाल है कि आप क्या एक पुल-अप रोकनेवाला हो सकता है। मैंने पुल-अप प्रतिरोधों पर एक व्यापक पोस्ट को कवर किया है जो आप इसे यहाँ सीखें ।

ठीक है, अब आगे बढ़ते हैं, आइए मुख्य लूप कोड देखें:

void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}

जब आप पुश बटन दबाते हैं, तो वायर्ड पिन जमीन से जुड़ जाता है, जो एक प्रदान करता है कम उस पिन को। और जबकि अनपनी स्थिति में एक ही पिन पर आयोजित किया जाता है उच्च या 20K आंतरिक पुल-अप रोकनेवाला के माध्यम से + 5V।

यहां हम चाहते हैं कि पुश बटन (LOW) दबाए जाने पर Arduino एलईडी को रोशन करे, इसलिए हम पुश बटन से LOW की हर प्रतिक्रिया के लिए आउटपुट के लिए HIGH लिखते हैं, जबकि इसे दबाया जाता है।

3.1.2 दो बटन और एक एलईडी

ठीक है, आप आश्चर्यचकित हो सकते हैं कि ऊपर दिखाए गए कार्य एक Arduino के बिना भी किए जा सकते हैं। मैं समझता हूं, हालांकि यह जानने के लिए एक मजबूत पत्थर है कि कैसे अर्दुनो के साथ पुश बटन का उपयोग किया जा सकता है।

इस बिंदु तक, हमने स्विच (ओएनई) या स्विचिंग ऑफ (एलओडब्ल्यू) को एलईडी के लिए लिखने के कोड का अध्ययन किया है।

अब देखते हैं कि Arduino के साथ LED की चमक को कैसे नियंत्रित किया जा सकता है।

यह दो तरीकों का उपयोग करके किया जा सकता है:

1. वर्तमान की मात्रा को एलईडी तक सीमित करके
2. का उपयोग करके पीडब्लूएम या पल्स चौड़ाई मॉड्यूलेशन, जिसमें एलईडी को आपूर्ति को कुछ वांछित दर पर बहुत तेजी से चालू / बंद किया जाता है, एक औसत रोशनी पैदा करता है जिसकी तीव्रता पीडब्लूएम पर निर्भर करेगी।

एक Arduino बोर्ड में PWM समर्थन एक टिल्ड (~) के साथ चिह्नित पिंस पर उपलब्ध है, जो 500Hz (500 बार एक सेकंड) पर पिन 3, 4,5,9,10 और 11) हैं। उपयोगकर्ता 0 और 255 के बीच कोई भी मूल्य प्रदान करने में सक्षम है, जहां 0 किसी भी उच्च या नहीं + 5V को संदर्भित नहीं करता है, और 255 Arduino को हर समय एक उच्च या +5V प्राप्त करने के लिए कहता है। इन आदेशों को आरंभ करने के लिए आपको एनालॉगवर्इट () को वांछित मान के साथ एक्सेस करना होगा।

आप पीडब्लूएम को x / 255 मान सकते हैं, जहाँ x वांछित मान है जिसे आप के माध्यम से भेजना चाहते हैं। _ + _ |

ऊपर दिखाए गए अनुसार Arduino और अन्य पैरामीटर सेट करें।

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}

आपको यहां कुछ स्पष्टीकरण की आवश्यकता वाली 3 लाइनें मिल सकती हैं।

for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}

पंक्ति: k_numLEDs - 1 Arduino के अंदर एक अनूठे समारोह को दिखाता है जिसे विवशता () के रूप में जाना जाता है।

इस आंतरिक फ़ंक्शन में निम्नलिखित कोड कोड शामिल हैं:

int की कमी (int value, int min, int max)
k_LEDPins[4]

इससे पहले शुरू किए गए सभी कोड पर चर्चा की गई शून्य , जिसका मतलब कुछ भी नहीं लौटाना (शून्य) था। जबकि उपरोक्त कोड से शुरू होता है पूर्णांक , जो इंगित करता है कि यह एक पूर्णांक लौटाता है। हम बाद के अनुभागों के बारे में अधिक चर्चा करेंगे, फिलहाल याद रखें कि पूर्णांक में कोई अंश नहीं है।

सही है, तो इसका मतलब है, कोड: const int kPinButton1 = 2
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}
void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
} असाइन करता है | _ _ + _ |

अगली पंक्ति कार्यरत है। _ + _ | वांछित मूल्य के साथ चयनित पिन पर पीडब्लूएम को स्पष्ट करने के लिए Arduino को आदेश देता है।

अगली पंक्ति 20 मिलीसेकंड की देरी पैदा करती है, यह सुनिश्चित करने के लिए है कि हम 50 हर्ट्ज या सेकंड से 50 गुना अधिक तेजी से समायोजित नहीं करते हैं। ऐसा इसलिए है क्योंकि मनुष्य एक Arduino की तुलना में बहुत धीमा हो सकता है। इसलिए यदि देरी नहीं हुई है तो कार्यक्रम हमें यह महसूस करवा सकता है कि पहले बटन को दबाने से एलईडी बंद हो गया और दूसरा बटन दबाने पर यह चालू हो गया (यह पुष्टि करने के लिए स्वयं प्रयास करें)।

३.२ पोटेंशियोमीटर

चलो आगे बढ़ते हैं और सीखते हैं कि कैसे उपयोग करना है Arduino के साथ पोटेंशियोमीटर।

यह जानने के लिए कि पोटेंशियोमीटर या पॉट कैसे काम करते हैं, आप इसे पढ़ सकते हैं लेख ।

ऊपर दिखाए गए अनुसार अपने मापदंडों को अपने Arduino के साथ कनेक्ट करें।

एक पॉट में 3 टर्मिनल होंगे। मध्य टर्मिनला Arduino पर ANALOG IN 0 से जुड़ेगा। अन्य दो बाहरी टर्मिनल + 5 वी और 0 वी आपूर्ति रेल से जुड़े हो सकते हैं।

आइए कार्यक्रम देखें और परिणाम देखें:

void setup()
{
pinMode(kPinButton1, INPUT)
digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor
pinMode(kPinLed, OUTPUT)
}

आपको कुछ ऐसी चीज़ें मिलेंगी जो पूरी तरह से नई लग सकती हैं और हमारे पहले के किसी भी कोड में शामिल नहीं हैं।

1. स्थिर void loop()
{
if(digitalRead(kPinButton1) == LOW){
digitalWrite(kPinLed, HIGH)
}
else{
digitalWrite(kPinLed, LOW)
}
} A0 के रूप में असाइन किया गया है, जिसमें A, एनालॉग पिनों में से एक का वर्णन करने के लिए शॉर्टकट है। हालाँकि A0 भी # 15 और इसके बाद के पिन को # 14, A1 को संदर्भित करता है, और ये आपको एक प्रयोग के लिए पिन से बाहर निकलने की स्थिति में डिजिटल इनपुट / ouputs के रूप में उपयोग करने की अनुमति देते हैं। लेकिन याद रखें कि आप एनालॉग पिन के रूप में डिजिटल पिन का उपयोग नहीं कर सकते हैं।
2. पंक्ति: analogWrite() Arduino के रूप में जाना जाता है के अंदर एक नया समारोह प्रस्तुत करता है नक्शा()। इस सुविधा को एक दिए गए रेंज से दूसरे में फिर से कैलिब्रेट किया जाता है, जिसे कहा जाता है नक्शा (मान, लिलो से, हाई, टोल, टूहाई)। यह महत्वपूर्ण हो सकता है क्योंकि const int kPinButton1 = 2
const int kPinButton2 = 3
const int kPinLed = 9
void setup()
{
pinMode(kPinButton1, INPUT)
pinMode(kPinButton2, INPUT)
pinMode(kPinLed, OUTPUT)
digitalWrite(kPinButton1, HIGH) // turn on pullup resistor
digitalWrite(kPinButton2, HIGH) // turn on pullup resistor
}
int ledBrightness = 128
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness--
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++
}
ledBrightness = constrain(ledBrightness, 0, 255)
analogWrite(kPinLed, ledBrightness)
delay(20)
} 0-1023 की सीमा के भीतर एक मान देता है, लेकिन एनालॉग वाइट 0-255 से मान स्वीकार करने में सक्षम है।

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

कोई बात नहीं, अब हम कुछ ऐसा करेंगे जो बिना Arduino के नहीं किया जा सकता।

इस प्रयोग में हम देखेंगे कि एक एलईडी की ब्लिंकिंग गति या दर को नियंत्रित करने के लिए एक पॉट के अलग प्रतिरोध का उपयोग कैसे किया जा सकता है।

यहाँ कार्यक्रम है:

ledBrightness = constrain(ledBrightness, 0, 255)
25 analogWrite(kPinLed, ledBrightness)
26 delay(20)

3.2.3 विलंब से बचना ()

उपरोक्त कोड अच्छा लग रहा है, लेकिन एलईडी पॉट मूल्य की जांच नहीं कर सकता है जब तक कि यह प्रत्येक पूर्ण चक्र से नहीं गुजरता है। इस प्रक्रिया में अधिक समय तक देरी होने पर उपयोगकर्ता को पॉट प्रतिक्रिया को देखने के लिए इंतजार करना पड़ता है जबकि वह इसे स्थानांतरित करता है। इस देरी को कुछ बुद्धिमान प्रोग्रामिंग से बचा जा सकता है, जिससे यह उपयोगकर्ता को न्यूनतम देरी के बिना मूल्य की जांच करने की अनुमति देता है। यहाँ कोड है।

ledBrightness = constrain(ledBrightness, 0, 255)

तो उपरोक्त कोड में ऐसा क्या है? यह निम्नलिखित पंक्ति है जो अंतर बनाती है।

{
if(value > max){
value = max
}
if(value value = min
}
return value
}

इस खंड तक, हमने चर int के बारे में चर्चा की है। हालाँकि, कई और प्रकार के चर हो सकते हैं जिन्हें आप एक्सेस कर सकते हैं। सूची नीचे पढ़ी जा सकती है:

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

यहां आप एक और दिलचस्प फंक्शन को देख सकते हैं मिलिस ()।

यह मिलीसेकंड में समय अवधि का उत्पादन करता है अरुडिनो ने शुरुआत से ही ऑपरेशन के दौरान काम किया (यह प्रत्येक 50 दिनों के बाद 0 पर रीसेट हो जाएगा)। यहां यह लंबा लौटता है क्योंकि अगर यह वापस लौट आए पूर्णांक लंबी अवधि के लिए गिनती संभव नहीं हो सकती है। क्या आप जवाब दे सकते हैं कि आखिर कब तक? उत्तर 32.767 सेकंड है।

इसलिए देरी () का उपयोग करने के बजाय, हम मिलिस () के लिए जांच करते हैं, और जैसे ही मिलीसेकंड की विशेष संख्या में हम एलईडी बदलते हैं। नतीजतन हम उस समय को संग्रहीत करते हैं, जिसे हमने इसे अंतिम रूप से बदला है पिछली बार परिवर्तनशील, ताकि यह जब चाहे तब हमें इसे फिर से जाँचने की अनुमति दे।

3.3 आरजीबी एलईडी

अब तक हमने सिंगल कलर एलईडी के साथ खेला है। यद्यपि एलईडी को दूसरे रंग से बदलकर एलईडी रंग बदला जा सकता है, लेकिन RGB LED का उपयोग कैसे किया जाता है एलईडी रंग बदलने के लिए एल ई डी बदलने के बिना?

आरजीबी एलईडी मूल रूप से एक लाल, हरे और नीले रंग की एलईडी वाली एलईडी होती है जिसे एक एलईडी में एम्बेडेड और मर्ज किया जाता है। इसमें एक सामान्य सीसा होता है जो जमीन या 0V सप्लाई रेल में जाता है जबकि अन्य 3 लीड्स को इच्छित PWM पॉजिटिव सिग्नल के साथ फीड किया जाता है। रंग मिश्रण ।

आप नीचे दिखाए अनुसार सेट अप तार कर सकते हैं:

यह थोड़ा जटिल लग सकता है, लेकिन वास्तव में यह PWM का उपयोग करके हमारे पहले के एलईडी नियंत्रण डिजाइन की प्रतिकृति है।

यहाँ एक अभ्यास कार्यक्रम कोड है:

ledBrightness = constrain(ledBrightness, 0, 255)

इस कोड को अपलोड करने के बाद, बस देखें कि पॉट समायोजन आरजीबी पर दिलचस्प प्रकाश प्रभाव कैसे बनाते हैं, यह एक वास्तविक मज़ा हो सकता है।

आप पाएंगे कि जब सभी 3 बर्तनों को अधिकतम स्थान पर ले जाया जाता है, तो सफेद रंग के बजाय आप लाल देखेंगे। ऐसा इसलिए है क्योंकि लाल रंग 3 रंगों में सबसे प्रमुख है और इसलिए इस स्थिति में हावी है। हालाँकि आप फ़ंक्शन के साथ प्रयोग कर सकते हैं नक्शा() , एक और अधिक समझदार संतुलन बनाने के लिए, एलईडी के लाल हिस्से को निष्पादित करने से पहले।

Arduino के साथ ऑडियो

इस खंड में हम सीखेंगे कि एक Arduino सेटअप में मूल ध्वनि और संगीत कैसे जोड़ा जाए।

हम देखेंगे कि किसी कनेक्टेड स्पीकर को सिग्नल को वांछित आवृत्ति के साथ कैसे स्विच किया जाए।

अधिक सटीक होने के लिए, एक मध्य ए नोट की कोशिश की जाएगी, जो कि 440 हर्ट्ज आवृत्ति नोट है।

ऐसा करने के लिए, हम बस एक मध्य A नोट खेलेंगे, और वर्ग तरंग के साथ साइन वेव सिग्नल को ऑप्टिमाइज़ करेंगे।

इसके अलावा, हम फॉर्मूला पर मुकदमा करके लाउडस्पीकर के चालू रहने की मात्रा की गणना करेंगे:

timeDelay = 1 सेकंड / 2 x टोनफ्रीक्वेंसी।

timeDelay = 1 सेकंड / 2 x 440

टाइमडेल = 1136 माइक्रोसेकंड

४.१ आर्डूइनो बोर्ड को हुक करते हैं

4.2 एक साधारण नोट जोड़ना

हम पहले ही फ़ंक्शन के बारे में चर्चा कर चुके हैं देरी () जहाँ इकाई मिलीसेकंड (दूसरी / 1000) में है, हालाँकि आपको अभी तक एक और कार्य नहीं मिलेगा ledBrightness to be within the range of 0 and 255 जहां इकाई माइक्रोसेकंड में है, (मिलीसेकंड / 1000)।

वर्तमान सेटअप के लिए, हम स्पीकर के साथ जुड़े चयनित पिन पर + 5V ON / OFF को स्विच करने के लिए एक कोड प्रोग्राम करते हैं, प्रति सेकंड 440 दालों की दर से।

स्मरण करो, पिछली चर्चा में हमने निर्धारित ऑडियो नोट के लिए मूल्य 1136 माइक्रोसेकंड निर्धारित किया था।

तो यहां इसके लिए एक कार्यक्रम है, जो आपको एक वक्ता के साथ arduino प्रोग्राम करते ही 440 हर्ट्ज का ऑडियो नोट सुनने की अनुमति देगा।

analogWrite

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

कोड से हम समझते हैं कि Arduino में कई एकीकृत कार्य शामिल हैं जो संगीत के निर्माण में योगदान देता है।

पहले वाला है सुर() जो 3 तत्वों के साथ 2 तत्वों के साथ काम करता है, जैसा कि निर्दिष्ट है टोन (पिन, आवृत्ति, अवधि)। या टोन (पिन, आवृत्ति)

दोनों आपके द्वारा सौंपी गई समयावधि से संबंधित निष्पादित करने के लिए निर्दिष्ट हैं।

समयावधि की अनुपस्थिति में, कॉल आने तक संगीत बजता रहेगा सुर() फिर से निष्पादित किया जाता है, या जब तक आप निष्पादित नहीं करते हैं एक नहीं ()।

यह एक विलंब फ़ंक्शन का उपयोग करके किया जाना चाहिए जब आप संगीत को लागू कर रहे हैं, तो केवल एक मूल बात है।

समय अवधि महत्वपूर्ण हो सकती है क्योंकि यह एक समय प्रदान करता है जब संगीत बजाया जाता है, इसलिए आप अन्य काम करने के लिए स्वतंत्र हो सकते हैं। जैसे ही अवधि व्यतीत हो जाती है, संगीत बंद हो जाता है।

अगला कार्य एक नहीं () एक एकल पैरामीटर को हैंडल करता है और किसी विशेष असाइन किए गए पिन पर चयनित टोन को रोकता है।

एक अजीब चेतावनी: कभी भी सुर() फ़ंक्शन लागू किया गया है, पिन 3 और 11 पर पीडब्लूएम फ़ंक्शन का संचालन बंद हो जाएगा।

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

एक वक्ता पर संगीत को लागू करने के लिए यहां ठीक है, हालांकि यह वास्तविक संगीत नहीं है बल्कि आधार सी नोट है।

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinPot, INPUT)
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int ledBrightness
int sensorValue = 0
sensorValue = analogRead(kPinPot)
ledBrightness = map(sensorValue, 0, 1023, 0, 255)
analogWrite(kPinLed, ledBrightness)
}

उपरोक्त कोड में आपने कुछ नया देखा होगा # डेफिन ।

यह शब्द कंप्यूटर के लिए एक खोज और प्रतिस्थापित कमांड की तरह काम करता है जबकि संकलन किया जा रहा है।

जब भी यह किसी स्थान से पहले पहली चीज को पाता है, तो यह इसे लाइन के शेष भाग (जिसे मैक्रोज़ कहा जाता है) से बदल देता है।

इसलिए इस उदाहरण के भीतर जब कंप्यूटर देखता है NOTE_E4 यह जल्दी से इसे 330 की मात्रा के साथ बदल देता है।

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

4.4 संगीत कार्यों के साथ

उपरोक्त कोड अच्छा लग रहा है, लेकिन लगता है कि कई पुनरावृत्तियाँ हैं, इन पुनरावृत्तियों को छोटा करने के लिए कोई तरीका होना चाहिए, है ना?

अब तक हमने Arduino के साथ शामिल दो आवश्यक कार्यों के साथ काम किया है। अब समय आ सकता है कि हम अपने स्वयं के कार्यों का निर्माण करें।

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

नतीजतन, विशेष फ़ंक्शन नाम को एक खुला कोष्ठक मिलता है '' ( अल्पविराम से अलग मापदंडों की एक सूची के बाद।

प्रत्येक पैरामीटर एक नाम के साथ अपने प्रकार को प्राप्त करता है, और अंत में एक करीब '' कोष्ठक।

इन मापदंडों को चर के रूप में फ़ंक्शन के भीतर लागू किया जा सकता है।

आइए नीचे एक उदाहरण देखें जहां हम एक फ़ंक्शन विकसित करते हैं जिसे कहा जाता है हमारा टोन () मर्ज करने के लिए बनाया गया है सुर() साथ से देरी () लाइनें, इस तरह से कि फ़ंक्शन तब तक वापस आना बंद हो जाता है जब तक कि नोट ने टोन खेलना समाप्त नहीं कर दिया।

हम अपने पिछले कोड में इन कार्यों को लागू करते हैं, और नीचे दिए गए प्रोग्राम को प्राप्त करते हैं, अंतिम पंक्तियों को देखते हैं:

kPinPot

प्रोग्राम को समझने में आसान बनाने के लिए फ़ंक्शंस बेहद आसान हो सकता है।

निम्नलिखित एक उदाहरण है जहां हम टोन की पसंद को निर्दिष्ट करने में सक्षम हैं जिसे हम दो सरणियों का उपयोग करके खेलना चाहते हैं। नोटों को बनाए रखने के लिए एक सरणी, दूसरा बीट्स को बनाए रखने के लिए।

ledBrightness = map(sensorValue, 0, 1023, 0, 255)

आप पहली पंक्ति में स्पष्ट रूप से देख सकते हैं #शामिल बयान। इस कथन का काम उद्धरणों के बीच की संपूर्ण फ़ाइल को चुनना और उसे उस स्थिति में रखना है #शामिल बयान। मानक नियमों के अनुसार इन्हें प्रोग्राम की शुरुआत में सख्ती से रखा जाता है।

अध्याय 5

मापने का तापमान

बस याद करने के लिए, बड़े कार्यक्रमों को पूरी तरह से लिखने के बजाय याद रखें, कोड के छोटे हिस्सों को लिखना और उनका विश्लेषण करना हमेशा बुद्धिमान होता है, जो गलतियों को जल्दी से ट्रैक करने में मदद करता है।

5.1 सीरियल मॉनिटर

अब तक, जिन कोड पर हमने चर्चा की है, वे त्वरित समस्या निवारण को आसान नहीं बनाते हैं। यहां हम संभव समस्या की निगरानी और आसान समाधान के लिए चीजों को आसान बनाने की कोशिश करेंगे।

Arduino में एक विशेषता है जो इसे कंप्यूटर के साथ 'वापस बात' करने में सक्षम बनाती है। आप देख सकते हैं कि pin0 और pin1 को एक दूसरे के बगल में RX TX के रूप में चिह्नित किया गया है। इन पिनों को वास्तव में Arduino के भीतर एक अलग IC द्वारा ट्रैक किया जाता है जो उन्हें PC में प्लग किए जाने के दौरान USB केबल पर पढ़ने के लिए अपग्रेड करता है।

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

analogueRead

आप यहां दो नई चीजों की पहचान कर सकते हैं, एक नई लाइन सेट अप() समारोह।

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
digitalWrite(kPinLed, HIGH)
delay(sensorValue)
digitalWrite(kPinLed, LOW)
delay(sensorValue)
}

यह लाइन बस का उपयोग करने की आवश्यकता को व्यक्त करती है धारावाहिक १ 9600 बॉड के साथ इसे लागू करने के लिए कोड। (यहाँ धारावाहिक से तात्पर्य है बिट्स एक के बाद एक भेजा, और बॉड का मतलब है जिस दर पर इसे भेजा जाता है)। यह बॉड मान और धारावाहिक मॉनीटर के अंदर (हम इसे बाद में सीखेंगे) बराबर होना चाहिए, अन्यथा सीरियल मॉनीटर में डेटा बकवास दिखाई देगा। 9600 मानक का उपयोग करने के लिए अधिक सुविधाजनक हो जाता है।

दूसरी नई प्रविष्टि इस प्रकार है

const int kPinPot = A0
const int kPinLed = 9
void setup()
{
pinMode(kPinLed, OUTPUT)
}
long lastTime = 0
int ledValue = LOW
void loop()
{
int sensorValue
sensorValue = analogRead(kPinPot)
if(millis() > lastTime + sensorValue){
if(ledValue == LOW){
ledValue = HIGH
}
else{
ledValue = LOW
}
lastTime = millis()
digitalWrite(kPinLed, ledValue)
}
}

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

एक और बात आप देख सकते हैं उद्धरण (') हैं। यह एक स्ट्रिंग के रूप में जाना जाता है, जिसका उपयोग केवल यहां स्थिरांक की तरह किया जाएगा, क्योंकि इस विषय पर आगे की चर्चा बहुत विस्तृत और दायरे से परे हो सकती है।

ठीक है, अब हम उपरोक्त कोड Arduino में अपलोड कर सकते हैं और देख सकते हैं कि क्या होता है।

क्या, उफ़ कुछ भी नहीं हुआ लगता है, Arduino पिन # 13 एलईडी झपकी और बंद कर दिया, जबकि Tx एलईडी पलक झपकते रहे।

खैर, ऐसा इसलिए है क्योंकि सीरियल मॉनिटर विंडो अभी तक तय नहीं है।

आपको अपने IDE में सीरियल मॉनिटर बॉक्स पर क्लिक करना होगा जैसा कि ऊपर दिखाया गया है। नीचे दाईं ओर स्थित बॉड दर की जांच करना न भूलें, डिफ़ॉल्ट रूप से यह 9600 होना चाहिए, और कोड से मेल खाएगा। यदि यह 9600 का चयन करना सुनिश्चित नहीं करता है।

निम्न वीडियो क्लिप बताती है कि यह कैसे किया जाता है।

अब आगे बढ़ते हैं और सीखते हैं कि उपरोक्त सीरियल मॉनिटर सुविधा प्रसंस्करण के लिए कैसे सहायता कर सकती है Arduino का उपयोग करके तापमान का मापन

-40 से 150 डिग्री सेल्सियस की सीमा वाले तापमान संवेदक के रूप में हम IC TMP36 का उपयोग करेंगे।

सेटअप को नीचे देखा जा सकता है:

निम्न कोड TMP36 सेंसर से आउटपुट को पढ़कर और आईडी के सीरियल मॉनिटर पर भेजकर तापमान की माप शुरू करेगा।

long lastTime = 0

ऊपर से कोड को समझते हैं।

const int kPinPot1 = A0
const int kPinPot2 = A1
const int kPinPot3 = A2
const int kPinLed_R = 6
const int kPinLed_G = 10
const int kPinLed_B = 11
void setup()
{
pinMode(kPinLed_R, OUTPUT)
pinMode(kPinLed_G, OUTPUT)
pinMode(kPinLed_B, OUTPUT)
}
void loop()
{
int potValue
int ledValue
potValue = analogRead(kPinPot1)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_R, ledValue)
potValue = analogRead(kPinPot2)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_G, ledValue)
potValue = analogRead(kPinPot3)
ledValue = map(potValue, 0, 1023, 0, 255)
analogWrite(kPinLed_B, ledValue)
}

यहां आप देख सकते हैं कि हमने चर प्रकार को शामिल किया है तैरना।

यह एकमात्र परिवर्तनशील प्रकार है जो पूर्णांक संख्याओं (दशमलव या भिन्नात्मक भागों के बिना संख्या) को छोड़कर सब कुछ संग्रहीत करने की सुविधा देता है।

फ्लोट चर से सटीकता 6 से 7 अंकों तक हो सकती है।

समीपवर्ती कोड delayMicroseconds() हमारा अपना कार्य है जो गणितीय रूप से TMP36 सेंसर से डिग्री सेल्सियस में संवेदी वोल्टेज अंतर की गणना करता है और परिवर्तित करता है।

const int kPinSpeaker = 9
const int k_timeDelay = 1136
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
digitalWrite(kPinSpeaker, HIGH)
delayMicroseconds(k_timeDelay)
digitalWrite(kPinSpeaker, LOW)
delayMicroseconds(k_timeDelay)
}

कोड के अगले भाग में, शब्द के बाद से #define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
} 1 से 1023 के बीच एक आंकड़ा वापस करने के लिए असाइन किया गया है, हमारे लिए सेंसर से वोल्टेज का आकलन करना संभव है हमारे रीडिंग को 5 से गुणा करके और फिर इसे 1024 से विभाजित करना।

सेंसर TMP36 0 डिग्री सेल्सियस पर 0.5V उत्पन्न करने के लिए निर्दिष्ट है, और बाद में डिग्री सेल्सियस में हर एक वृद्धि के लिए 10mV उत्पन्न करता है।

यहाँ अनुमान है कि हम गणना के माध्यम से उत्पन्न करने में सक्षम हैं:

आप अपने पहले फ़ंक्शन पर विचार कर सकते हैं जो कुछ मान लौटाता है (ध्यान दें कि अब तक के सभी शेष कार्य किसी भी मूल्य पर वापस नहीं आए हैं क्योंकि वे इस प्रकार के हैं शून्य ) है।

आप समझ सकते हैं कि किसी फ़ंक्शन से मान प्राप्त करने के लिए, आपको बस जोड़ने की आवश्यकता है वापसी इच्छित संख्या के बाद आप वापस लौटना चाहते हैं।

जब हम कहते हैं वापसी इसका मतलब यह है कि फ़ंक्शन जब भी बुलाया जाता है, तो एक प्रतिक्रिया या एक उत्तर देता है, जिसे एक चर पर लागू किया जा सकता है।

जब यह सीरियल मॉनिटर को भेजा जाता है, तो रीडिंग फ़ारेनहाइट में परिवर्तित हो जाती है ConvertToF ()।

#define NOTE_C4 262
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
const int kPinSpeaker = 9
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
tone(kPinSpeaker, NOTE_C4, 500)
delay(500)
tone(kPinSpeaker, NOTE_D4, 500)
delay(500)
tone(kPinSpeaker, NOTE_E4, 500)
delay(500)
tone(kPinSpeaker, NOTE_F4, 500)
delay(500)
tone(kPinSpeaker, NOTE_G4, 500)
delay(500)
tone(kPinSpeaker, NOTE_A4, 500)
delay(500)
tone(kPinSpeaker, NOTE_B4, 500)
delay(500)
tone(kPinSpeaker, NOTE_C5, 500)
delay(500)
noTone(kPinSpeaker)
delay(2000)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

यह फ़ंक्शन सेल्सियस रेंज को उठाता है और इसे फ़ारेनहाइट में परिवर्तित करता है।

फ़ारेनहाइट को सेल्सियस में परिवर्तित करने के लिए हम सूत्र को लागू करते हैं फ़ारेनहाइट = 9 / 5 (सेल्सियस) + 32।

5.3 एक एलसीडी की जगह

अब आइए अध्ययन करें कि इंटरफ़ेस कैसे या कनेक्ट करें आयसीडी प्रदर्शन आवश्यक आउटपुट के लिए दृश्य प्रदर्शन प्राप्त करने के लिए Arduino के साथ।

हमारे आवेदन में हम 84 पिक्सेल या डॉट्स क्षैतिज रूप से, और 48 पिक्सेल ऊर्ध्वाधर रिज़ॉल्यूशन वाले 84x48 ग्राफिकल एलसीडी को नियोजित करने जा रहे हैं। चूंकि सभी एलसीडी के लिए एक समर्पित नियंत्रक अनिवार्य हो जाता है, वर्तमान डिवाइस भी PCD8544 नियंत्रक के रूप में एक को शामिल करता है।

इस ट्यूटोरियल में हम उपरोक्त निर्दिष्ट एलसीडी मॉड्यूल को Arduino के साथ जोड़ेंगे, और डिस्प्ले पर टेक्स्ट संदेश बनाने के लिए कुछ रूटीन लागू करेंगे।

निम्नलिखित आकृति में आप एक छोटे के साथ, एलसीडी के इंटरफेसिंग के बारे में विवरण पा सकते हैं 3.3V वोल्टेज नियामक । यह नियामक आवश्यक है क्योंकि एलसीडी 3.3V आपूर्ति के साथ काम करने के लिए निर्दिष्ट है।

आप एलसीडी मॉड्यूल से 8 पिनआउट भी देख सकते हैं, पिनआउट विनिर्देशों का अध्ययन निम्न तालिका से किया जा सकता है:

अब देखते हैं कि हम एलसीडी और संबंधित मापदंडों को अपने Arduino के साथ कैसे जोड़ सकते हैं। नीचे दिखाए गए चित्रण में विवरण की कल्पना की जा सकती है:

5.4 एलसीडी के लिए संचार

हालाँकि, Arduino से LCD के साथ बातचीत करने के लिए विस्तृत coeds लिखना संभव है, हम यह सीखेंगे कि पुस्तकालयों का उपयोग करना कैसे करना है।

पुस्तकालयों में कोडों का एक वर्गीकरण होता है, जो एक चयनित Arduino प्रोग्राम के लिए जल्दी से लागू किया जा सकता है।

यह उपयोगकर्ता को जटिल कोडिंग कार्य से गुजरने के बिना आसानी से फ़ंक्शन को कॉल करने में सक्षम बनाता है।

5.4.1 पुस्तकालय को कैसे स्थापित करें

इसके लिए आपको अपने कंप्यूटर Arduino IDE में लाइब्रेरी नामक एक निर्देशिका बनानी होगी यहां

5.4.2 एलसीडी संचालन को लागू करना

हमारे पिछले दृष्टिकोण के रूप में, हम पहले पूरे कोड की जांच करेंगे और फिर व्यक्तिगत लाइनों के विवरण को समझने का प्रयास करेंगे।

#include 'pitches.h'
int kPinSpeaker = 9
#define NUM_NOTES 15
const int notes[NUM_NOTES] = // a 0 represents a rest
{
NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4,
NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4,
NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4,
NOTE_D4, NOTE_C4, 0
}
const int beats[NUM_NOTES] = {
1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 }
const int beat_length = 300
void setup()
{
pinMode(kPinSpeaker, OUTPUT)
}
void loop()
{
for (int i = 0 i if (notes[i] == 0) {
delay(beats[i] * beat_length) // rest
}
else {
ourTone(notes[i], beats[i] * beat_length)
}
// pause between notes
noTone(kPinSpeaker)
delay(beat_length / 2)
}
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

लाइन में कोड शामिल है। _ + _ |

कोड #include पीसी को उल्लेखित फ़ाइल को पिक करने का निर्देश देता है और प्रोग्राम के संकलन के दौरान फ़ाइल सामग्री के साथ #include तत्व को प्रतिस्थापित करता है।

#Include तत्व में कोण कोष्ठक हो सकते हैं जो लाइब्रेरी डायरेक्टरी में खोज को इंगित करता है, वैकल्पिक रूप से इसमें ऐसे कोट्स भी हो सकते हैं जो उसी डाइरेक्टरी में खोज करने का संकेत देते हैं जिसमें प्रोग्राम स्थित है।

कोड की बाद की पंक्तियाँ एलसीडी पिनआउट को व्यक्त करती हैं, और फिर हम एक नया रूप चर लिखते हैं:

const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
Serial.begin(9600)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If it would have been zero or less, reset it.
delayTime = 1000
}
Serial.print('delayTime = ')
Serial.println(delayTime)
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}

यहाँ हम PCD8544 प्रकार के एलसीडी नाम के साथ एक चर व्यक्त कर रहे हैं और पीसी को Arduino के साथ जुड़े अपने पिनआउट को फिर से निर्देशित कर रहे हैं।

इस प्रक्रिया में हम पीसी को चर का वर्णन करते हुए निर्देश देते हैं कि पिन क्लक, डिन, डीसी और रीसेट कैसे अरुदीनो के साथ हस्तक्षेप करते हैं।

Serial.begin(9600)

लाइन Serial.print('delayTime = ')
Serial.println(delayTime) एलसीडी ऑपरेशन को इनिशियलाइज़ करता है। एक बार जब यह निष्पादित हो जाता है, तो अगली पंक्ति प्रदर्शन के ऊपरी बाईं ओर एक कर्सर लागू करती है। और बाद की अगली पंक्ति 'हैलो, वर्ल्ड' संदेश को प्रिंट करने का प्रयास करती है।

यह उस तकनीक से काफी मिलता-जुलता है जिसमें हमने सीरियल मॉनीटर पर संदेश भेजे थे। केवल कोड के उपयोग से अंतर होता है const int kPinTemp = A0
void setup()
{
Serial.begin(9600)
}
void loop()
{
float temperatureC = getTemperatureC()
Serial.print(temperatureC)
Serial.println(' degrees C')
// now convert to Fahrenheit
float temperatureF = convertToF(temperatureC)
Serial.print(temperatureF)
Serial.println(' degrees F')
delay(500)
}
float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}
float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
} बजाय सीरियल.प्रिंट के।

कोड का अगला ब्लॉक वास्तव में दोहराव से कहा जाता है।

float temperatureC = getTemperatureC()

इस लाइन का उपयोग करना getTemperatureC() हम एलसीडी डिस्प्ले के ऊपर, पहली पंक्ति के बाईं ओर स्थित 0 कॉलम पर कर्सर को ठीक करते हैं।

अगली पंक्ति एक शॉर्टकट नियुक्त करती है: float getTemperatureC()
{
int reading = analogRead(kPinTemp)
float voltage = (reading * 5.0) / 1024
// convert from 10 mv per degree with 500mV offset
// to degrees ((voltage - 500mV) * 100)
return (voltage - 0.5) * 100
}

अगर आपको याद है कि हमने साथ काम किया है analogIn() हमारे पहले के कोड में, हम यहां भी कोड के माध्यम से ही आवेदन कर सकते थे:

float convertToF(float temperatureC)
{
return (temperatureC * 9.0 / 5.0) + 32.0
}

हालाँकि इस तथ्य के कारण कि यहाँ मिलीसेकंड में कोई समयावधि शामिल नहीं है, इसलिए हम इसे केवल भेजकर पूरा करते हैं #include
const int kPin_CLK = 5
const int kPin_DIN = 6
const int kPin_DC = 7
const int kPin_RESET = 8
PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)
void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}
void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
} समारोह सीधे #include ।

5.5 सम्पूर्ण थिंग का संयोजन

ठीक है, अब हम एलसीडी कोड सर्किट बनाने के लिए ऊपर दिए गए सभी कोडों को जोड़ते हैं, और देखते हैं कि यह कैसा दिखता है:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

फ़ंक्शन के उपयोग को छोड़कर, उपरोक्त कार्यक्रम में सब कुछ मानक दिखता है setCursor () । यह प्रदर्शन के केंद्र के चारों ओर जहाँ तक संभव हो पाठ को संरेखित करने के लिए नियोजित है।

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

व्यावहारिक Arduino अनुप्रयोग

चूंकि, इस बिंदु पर हमने विभिन्न प्रोग्रामिंग तकनीकों को विस्तार से कवर किया है, इसलिए कुछ उपयोगी व्यावहारिक कार्यान्वयन के लिए उन्हें लागू करने के माध्यम से उन्हें आगे बढ़ाने का समय है।

हम सेंसर के साथ शुरू करेंगे और देखेंगे कि कुछ नमूना कोडों को निष्पादित करके Arduino के साथ सेंसर उपकरणों का उपयोग कैसे किया जा सकता है।

7.1 सेंसर का परिचय

इस ट्यूटोरियल में हम विभिन्न प्रकार के सेंसरों के बारे में जानेंगे जिनका उपयोग Arduino के साथ किया जा सकता है। इनमें लाइट सेंसर LDR, मैग्नेटिक हॉल इफेक्ट सेंसर, टिल्ट सेंसर, वाइब्रेशन सेंसर, प्रेशर सेंसर आदि जैसे उपकरण शामिल हो सकते हैं।

हम के इंटरफेसिंग के साथ शुरू करेंगे प्रकाश संवेदक एलडीआर Arduino के साथ, जैसा कि मैंने निम्नलिखित चित्र दिखाया है:

जैसा कि हम सभी जानते हैं, LDR एक प्रकाश पर निर्भर प्रतिरोधक उपकरण है जिसका प्रतिरोध इसकी सतह पर परिवेशीय घटना की तीव्रता पर निर्भर करता है।

प्रकाश की तीव्रता एलडीआर के प्रतिरोध पढ़ने के विपरीत आनुपातिक है।

यहां हम जानेंगे कि कैसे एक उपयोगी एप्लिकेशन को निष्पादित करने के लिए इस संपत्ति को Arduino के साथ एकीकृत किया जा सकता है:

पूरा कार्यक्रम कोड नीचे दिए गए रूप में देखा जा सकता है:

void setup()
{
lcd.init()
lcd.setCursor(0,0)
lcd.print('Hello, World!')
}

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

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

टिल्ट सेंसर

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

अब देखते हैं कि ए टिल्ट सेंसर डिवाइस को वायर्ड किया जा सकता है। नीचे दी गई छवि हमें पूर्ण कॉन्फ़िगरेशन के बारे में एक विचार देती है:

lcd.init()

इस उदाहरण में डिफ़ॉल्ट पिन # 13 एलईडी का उपयोग झुकाव संकेतक के रूप में किया जाता है।

आप स्पष्ट रूप से पुल-अप रोकनेवाला के समावेश को यहाँ देख सकते हैं, काफी कुछ ऐसा ही हमने खंड 3.1 में किया था। इसलिए LOW शब्द इंगित करता है कि झुकाव फ़ंक्शन ट्रिगर नहीं है।

7.4 रीड स्विच रिले (लघु चुंबक सक्रिय रिले)

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

यहां भी हम प्रतिक्रिया का संकेत देने के लिए पिन # 13 एलईडी का उपयोग करते हैं। यदि आप हमारे पूर्व स्पष्टीकरणों के अनुसार आवश्यकता हो तो इस पिन से एक बाहरी एलईडी कनेक्ट कर सकते हैं।

lcd.print

कोड की शर्तें परिचित और आत्म व्याख्यात्मक होनी चाहिए।

7.5 पीजो ट्रांसड्यूसर का उपयोग करते हुए कंपन सेंसर

अगले नमूना कार्यक्रम में हम देखेंगे कि कैसे पीजो ट्रांसड्यूसर Arduino के माध्यम से एक एलईडी को रोशन करने के लिए एक कंपन सेंसर के रूप में इस्तेमाल किया जा सकता है।

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

Arduino और एक पीजो तत्व को निम्न आकृति में दिए अनुसार सेट करें

void loop()
{
lcd.setCursor(0,1)
lcd.print(millis())
}

थ्रेशोल्ड 100 को केवल यह सुनिश्चित करने के लिए पेश किया गया है कि Arduino केवल वास्तविक कंपन को नॉक के माध्यम से प्रतिक्रिया करता है, न कि अन्य छोटे कंपन जैसे कि तेज आवाज़, या सींग से।

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

Arduino के साथ सर्वो मोटर का उपयोग करना

इमदादी मोटर एक प्रकार की डीसी मोटर होती है जिसे किसी विशेष एप्लिकेशन की मांग के अनुसार सटीक कोणों पर घुमाया जा सकता है। यह मोटर पर 180 डिग्री रेंज के भीतर एक सटीक घूर्णी या मोड़ कोण का उत्पादन करने के लिए मोटर के प्रासंगिक आदानों के लिए एक गणना आदेश लागू करके किया जा सकता है।

आमतौर पर एक सर्वो मोटर में 3 तार या इनपुट होते हैं। सकारात्मक तार सामान्य रूप से लाल रंग के होते हैं, नकारात्मक या जमीन का तार काला होता है, जो कमांड वायर या सिग्नलिंग तार सामान्य रूप से सफेद या पीले रंग का होता है।

Arduino, सहायक भाषा में निर्मित इमदादी मोटर नियंत्रण की सुविधा देता है जो सर्वो मोटर्स के लिए बहुत सुविधाजनक और आदर्श को नियंत्रित करता है।

निम्न उदाहरण हमें Arduino के माध्यम से इमदादी मोटर नियंत्रण को लागू करने के लिए बुनियादी सेटअप कार्यक्रम दिखाएगा:

कोड नीचे दिया गया है:

lcd.setCursor(0,1)

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

निष्कर्ष

Arduino विषय असीम रूप से लंबा हो सकता है, और इसलिए इस लेख के दायरे से परे है। हालाँकि, मुझे उम्मीद है कि उपरोक्त ट्यूटोरियल ने निश्चित रूप से आपको Arduino की मूल बातें सीखने में मदद की होगी, और विभिन्न उदाहरण एप्लिकेशन कोड के माध्यम से महत्वपूर्ण मापदंडों को समझना चाहिए।

उम्मीद है कि जब भी यह उपलब्ध हो, तो समय-समय पर और जानकारी अपडेट की जा सकती है।

इस बीच, अपने प्रोग्रामिंग कोर्स का आनंद लें, आपको हैप्पी Arduinoing !!