Arduino - त्वरित गाइड

Arduino एक आसान हार्डवेयर और सॉफ्टवेयर के आधार पर एक प्रोटोटाइप मंच (ओपन-सोर्स) है। इसमें एक सर्किट बोर्ड होता है, जिसे प्रोग्राम किया जा सकता है (जिसे एक माइक्रोकंट्रोलर के रूप में संदर्भित किया जाता है) और एक रेडी-मेड सॉफ्टवेयर जिसे Arduino IDE (इंटीग्रेटेड डेवलपमेंट एनवायरनमेंट) कहा जाता है, जिसका उपयोग कंप्यूटर कोड को भौतिक बोर्ड पर लिखने और अपलोड करने के लिए किया जाता है।

प्रमुख विशेषताएं हैं -

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

  • आप Arduino IDE (सॉफ्टवेयर अपलोड करने के रूप में संदर्भित) के माध्यम से बोर्ड पर माइक्रोकंट्रोलर को निर्देशों का एक सेट भेजकर अपने बोर्ड के कार्यों को नियंत्रित कर सकते हैं।

  • अधिकांश पिछले प्रोग्रामेबल सर्किट बोर्ड के विपरीत, बोर्ड पर एक नया कोड लोड करने के लिए, Arduino को हार्डवेयर के एक अतिरिक्त टुकड़े (जिसे प्रोग्रामर कहा जाता है) की आवश्यकता नहीं होती है। आप बस एक यूएसबी केबल का उपयोग कर सकते हैं।

  • इसके अतिरिक्त, Arduino IDE C ++ के सरलीकृत संस्करण का उपयोग करता है, जिससे प्रोग्राम को सीखना आसान हो जाता है।

  • अंत में, Arduino एक मानक प्रपत्र कारक प्रदान करता है जो माइक्रो-नियंत्रक के कार्यों को अधिक सुलभ पैकेज में तोड़ता है।

बोर्ड के प्रकार

उपयोग किए जाने वाले विभिन्न माइक्रोकंट्रोलर के आधार पर विभिन्न प्रकार के Arduino बोर्ड उपलब्ध हैं। हालांकि, सभी Arduino बोर्डों में एक चीज समान है: उन्हें Arduino IDE के माध्यम से प्रोग्राम किया जाता है।

अंतर इनपुट और आउटपुट (सेंसर, एल ई डी, और बटन की संख्या आप एक बोर्ड पर उपयोग कर सकते हैं), गति, ऑपरेटिंग वोल्टेज, फॉर्म फैक्टर आदि की संख्या पर आधारित हैं। कुछ बोर्ड एम्बेडेड होने के लिए डिज़ाइन किए गए हैं और इनमें कोई प्रोग्रामिंग नहीं है इंटरफ़ेस (हार्डवेयर), जिसे आपको अलग से खरीदना होगा। कुछ सीधे 3.7V बैटरी से चल सकते हैं, अन्य को कम से कम 5V की आवश्यकता होती है।

यहाँ विभिन्न Arduino बोर्डों की एक सूची उपलब्ध है।

Arduino boards based on ATMEGA328 microcontroller

बोर्ड का नाम ऑपरेटिंग वोल्ट घड़ी की गति डिजिटल आई / ओ एनालॉग इनपुट PWM UART प्रोग्रामिंग इंटरफ़ेस
अरुडिनो उनो आर 3 5V 16MHz 14 6 6 1 ATMega16U2 के माध्यम से यूएसबी
Arduino Uno R3 SMD 5V 16MHz 14 6 6 1 ATMega16U2 के माध्यम से यूएसबी
रेड बोर्ड 5V 16MHz 14 6 6 1 FTDI के माध्यम से यूएसबी
Arduino Pro 3.3v / 8 MHz 3.3 8MHz 14 6 6 1 FTDI- संगत हैडर
Arduino Pro 5V / 16MHz 5V 16MHz 14 6 6 1 FTDI- संगत हैडर
अरडिनो मिनी 05 5V 16MHz 14 8 6 1 FTDI- संगत हैडर
Arduino Pro मिनी 3.3v / 8mhz 3.3 8MHz 14 8 6 1 FTDI- संगत हैडर
Arduino Pro मिनी 5v / 16mhz 5V 16MHz 14 8 6 1 FTDI- संगत हैडर
Arduino ईथरनेट 5V 16MHz 14 6 6 1 FTDI- संगत हैडर
आर्डुइनो फियो 3.3 8MHz 14 8 6 1 FTDI- संगत हैडर
लिलीपैड अरुडिनो 328 मुख्य बोर्ड 3.3 8MHz 14 6 6 1 FTDI- संगत हैडर
लिलीपैड Arduino सरल बोर्ड 3.3 8MHz 9 4 5 0 FTDI- संगत हैडर

Arduino boards based on ATMEGA32u4 microcontroller

बोर्ड का नाम ऑपरेटिंग वोल्ट घड़ी की गति डिजिटल आई / ओ एनालॉग इनपुट PWM UART प्रोग्रामिंग इंटरफ़ेस
अरुडिनो लियोनार्डो 5V 16MHz 20 12 7 1 देशी यूएसबी
प्रो माइक्रो 5V / 16MHz 5V 16MHz 14 6 6 1 देशी यूएसबी
प्रो माइक्रो 3.3V / 8MHz 5V 16MHz 14 6 6 1 देशी यूएसबी
लिलीपैड Arduino USB 3.3 8MHz 14 6 6 1 देशी यूएसबी

Arduino boards based on ATMEGA2560 microcontroller

बोर्ड का नाम ऑपरेटिंग वोल्ट घड़ी की गति डिजिटल आई / ओ एनालॉग इनपुट PWM UART प्रोग्रामिंग इंटरफ़ेस
Arduino मेगा 2560 R3 5V 16MHz 54 16 14 4 ATMega16U2B के माध्यम से यूएसबी
मेगा प्रो 3.3V 3.3 8MHz 54 16 14 4 FTDI- संगत हैडर
मेगा प्रो 5 वी 5V 16MHz 54 16 14 4 FTDI- संगत हैडर
मेगा प्रो मिनी 3.3 वी 3.3 8MHz 54 16 14 4 FTDI- संगत हैडर

Arduino boards based on AT91SAM3X8E microcontroller

बोर्ड का नाम ऑपरेटिंग वोल्ट घड़ी की गति डिजिटल आई / ओ एनालॉग इनपुट PWM UART प्रोग्रामिंग इंटरफ़ेस
Arduino मेगा 2560 R3 3.3 84MHz 54 12 12 4 USB देशी

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

Power USB

आपके कंप्यूटर से USB केबल का उपयोग करके Arduino बोर्ड को संचालित किया जा सकता है। आपको बस USB केबल को USB कनेक्शन (1) से कनेक्ट करना है।

Power (Barrel Jack)

Arduino बोर्डों को सीधे बैरेल जैक (2) से जोड़कर एसी मेन बिजली आपूर्ति से संचालित किया जा सकता है।

Voltage Regulator

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

Crystal Oscillator

क्रिस्टल थरथरानवाला Arduino को समय के मुद्दों से निपटने में मदद करता है। Arduino समय की गणना कैसे करता है? जवाब है, क्रिस्टल थरथरानवाला का उपयोग करके। Arduino क्रिस्टल के शीर्ष पर मुद्रित संख्या 16.000H9H है। यह हमें बताता है कि आवृत्ति 16,000,000 हर्ट्ज या 16 मेगाहर्ट्ज है।

Arduino Reset

आप अपने Arduino बोर्ड को रीसेट कर सकते हैं, अर्थात, अपना कार्यक्रम शुरू से शुरू करें। आप यूएनओ बोर्ड को दो तरीकों से रीसेट कर सकते हैं। सबसे पहले, बोर्ड पर रीसेट बटन (17) का उपयोग करके। दूसरा, आप RESET (5) लेबल वाले Arduino पिन से एक बाहरी रीसेट बटन कनेक्ट कर सकते हैं।

Pins (3.3, 5, GND, Vin)

  • 3.3V (6) - 3.3 आउटपुट वोल्ट की आपूर्ति

  • 5 वी (7) - आपूर्ति 5 आउटपुट वोल्ट

  • Arduino बोर्ड के साथ उपयोग किए जाने वाले अधिकांश घटक 3.3 वोल्ट और 5 वोल्ट के साथ ठीक काम करते हैं।

  • GND (8) (ग्राउंड) - Arduino पर कई GND पिन हैं, जिनमें से किसी का उपयोग आपके सर्किट को ग्राउंड करने के लिए किया जा सकता है।

  • विन (9) - इस पिन का उपयोग बाहरी बिजली स्रोत से एसी मेन पावर सप्लाई जैसे अरुडिनो बोर्ड को बिजली देने के लिए भी किया जा सकता है।

Analog pins

Arduino UNO बोर्ड में A5 के माध्यम से छह एनालॉग इनपुट पिन A0 हैं। ये पिन नमी सेंसर या तापमान सेंसर जैसे एनालॉग सेंसर से सिग्नल पढ़ सकते हैं और इसे एक डिजिटल मूल्य में बदल सकते हैं जिसे माइक्रोप्रोसेसर द्वारा पढ़ा जा सकता है।

Main microcontroller

प्रत्येक Arduino बोर्ड का अपना माइक्रोकंट्रोलर (11) है। आप इसे अपने बोर्ड के मस्तिष्क के रूप में मान सकते हैं। अर्डुइनो पर मुख्य आईसी (एकीकृत सर्किट) बोर्ड से बोर्ड से थोड़ा अलग है। माइक्रोकंट्रोलर आमतौर पर ATMEL कंपनी के होते हैं। आपको पता होना चाहिए कि Arduino IDE से एक नया प्रोग्राम लोड करने से पहले आपके बोर्ड में क्या IC है। यह जानकारी आईसी के शीर्ष पर उपलब्ध है। आईसी निर्माण और कार्यों के बारे में अधिक जानकारी के लिए, आप डेटा शीट का उल्लेख कर सकते हैं।

ICSP pin

अधिकतर, ICSP (12) एक AVR है, जो Arduino के लिए MOSI, MISO, SCK, RESET, VCC और GND से मिलकर एक छोटी प्रोग्रामिंग हैडर है। इसे अक्सर एक SPI (सीरियल पेरिफेरल इंटरफेस) के रूप में जाना जाता है, जिसे आउटपुट का "विस्तार" माना जा सकता है। दरअसल, आप SPI बस के मास्टर को आउटपुट डिवाइस स्लाव कर रहे हैं।

Power LED indicator

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

TX and RX LEDs

आपके बोर्ड पर, आपको दो लेबल मिलेंगे: TX (ट्रांसमिट) और RX (प्राप्त)। वे Arduino UNO बोर्ड में दो स्थानों पर दिखाई देते हैं। सबसे पहले, डिजिटल पिन 0 और 1 पर, सीरियल संचार के लिए जिम्मेदार पिन को इंगित करने के लिए। दूसरा, TX और RX का नेतृत्व किया (13)। सीरियल डेटा भेजते समय TX अलग-अलग गति के साथ चमकता था। चमकती की गति बोर्ड द्वारा उपयोग की जाने वाली बॉड दर पर निर्भर करती है। प्राप्त करने की प्रक्रिया के दौरान आरएक्स चमकता है।

Digital I/O

Arduino UNO बोर्ड में 14 डिजिटल I / O पिंस (15) हैं (जिनमें से 6 PWM (पल्स चौड़ाई मॉडुलन) आउटपुट प्रदान करते हैं। इन पिनों को लॉजिक मान (0 या 1 या डिजिटल) पढ़ने के लिए इनपुट डिजिटल पिन के रूप में काम करने के लिए कॉन्फ़िगर किया जा सकता है। एल ई डी, रिले, आदि जैसे विभिन्न मॉड्यूल को चलाने के लिए आउटपुट पिन "~" लेबल वाले पिन का उपयोग PWM उत्पन्न करने के लिए किया जा सकता है।

AREF

AREF एनालॉग संदर्भ के लिए खड़ा है। यह कभी-कभी, बाहरी इनपुट वोल्टेज (0 और 5 वोल्ट के बीच) को एनालॉग इनपुट पिन के लिए ऊपरी सीमा के रूप में सेट करने के लिए उपयोग किया जाता है।

Arduino UNO बोर्ड के मुख्य भागों के बारे में जानने के बाद, हम यह जानने के लिए तैयार हैं कि Arduino IDE कैसे सेट किया जाए। एक बार जब हम यह सीख लेते हैं, तो हम Arduino बोर्ड पर अपना प्रोग्राम अपलोड करने के लिए तैयार होंगे।

इस खंड में, हम आसान चरणों में सीखेंगे कि हमारे कंप्यूटर पर Arduino IDE कैसे सेट करें और USB केबल के माध्यम से प्रोग्राम प्राप्त करने के लिए बोर्ड तैयार करें।

Step 1- सबसे पहले आपके पास अपना Arduino बोर्ड होना चाहिए (आप अपना पसंदीदा बोर्ड चुन सकते हैं) और USB केबल। यदि आप Arduino UNO, Arduino Duemilanove, Nano, Arduino Mega 2560, या Diecimila का उपयोग करते हैं, तो आपको एक मानक USB केबल (A प्लग से B प्लग) की आवश्यकता होगी, जिस प्रकार आप USB प्रिंटर से कनेक्ट करेंगे जैसा कि निम्नलिखित छवि में दिखाया गया है।

यदि आप Arduino Nano का उपयोग करते हैं, तो आपको निम्न छवि में दिखाए गए अनुसार A से Mini-B केबल की आवश्यकता होगी।

Step 2 − Download Arduino IDE Software.

आप Arduino IDE के विभिन्न संस्करणों को Arduino की आधिकारिक वेबसाइट पर डाउनलोड पृष्ठ से प्राप्त कर सकते हैं । आपको अपने सॉफ़्टवेयर का चयन करना होगा, जो आपके ऑपरेटिंग सिस्टम (विंडोज, आईओएस या लिनक्स) के अनुकूल है। आपकी फ़ाइल डाउनलोड पूर्ण होने के बाद, फ़ाइल को अनज़िप करें।

Step 3 − Power up your board.

Arduino Uno, Mega, Duemilanove और Arduino Nano स्वचालित रूप से या तो पावर, कंप्यूटर से USB कनेक्शन या बाहरी बिजली की आपूर्ति करते हैं। यदि आप एक Arduino Diecimila का उपयोग कर रहे हैं, तो आपको यह सुनिश्चित करना होगा कि बोर्ड USB कनेक्शन से बिजली खींचने के लिए कॉन्फ़िगर किया गया है। पावर स्रोत को एक जम्पर के साथ चुना जाता है, प्लास्टिक का एक छोटा टुकड़ा जो यूएसबी और पावर जैक के बीच दो तीन पिन पर फिट बैठता है। जांचें कि यह यूएसबी पोर्ट के निकटतम दो पिनों पर है।

USB केबल का उपयोग करके Arduino बोर्ड को अपने कंप्यूटर से कनेक्ट करें। ग्रीन पावर एलईडी (पीडब्लूआर लेबल) को चमकना चाहिए।

Step 4 − Launch Arduino IDE.

आपके Arduino IDE सॉफ़्टवेयर डाउनलोड होने के बाद, आपको फ़ोल्डर को अनज़िप करना होगा। फ़ोल्डर के अंदर, आप एक अनन्तता लेबल (Application.exe) के साथ एप्लिकेशन आइकन पा सकते हैं। IDE शुरू करने के लिए आइकन पर डबल-क्लिक करें।

Step 5 − Open your first project.

एक बार सॉफ्टवेयर शुरू होने के बाद, आपके पास दो विकल्प हैं -

  • एक नया प्रोजेक्ट बनाएं।
  • एक मौजूदा प्रोजेक्ट उदाहरण खोलें।

एक नया प्रोजेक्ट बनाने के लिए, फ़ाइल → का चयन करें New।

किसी मौजूदा प्रोजेक्ट उदाहरण को खोलने के लिए, फ़ाइल → उदाहरण → बेसिक्स → ब्लिंक का चयन करें।

यहां, हम नाम के साथ केवल एक उदाहरण का चयन कर रहे हैं Blink। यह कुछ समय की देरी के साथ एलईडी को बंद और चालू करता है। आप सूची से किसी अन्य उदाहरण का चयन कर सकते हैं।

Step 6 − Select your Arduino board.

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

टूल → बोर्ड पर जाएं और अपना बोर्ड चुनें।

यहां, हमने अपने ट्यूटोरियल के अनुसार Arduino Uno बोर्ड को चुना है, लेकिन आपको उस बोर्ड से मेल खाने वाले नाम का चयन करना होगा जिसका आप उपयोग कर रहे हैं।

Step 7 − Select your serial port.

Arduino बोर्ड के सीरियल डिवाइस का चयन करें। के लिए जाओTools → Serial Portमेन्यू। यह COM3 या उच्चतर होने की संभावना है (COM1 और COM2 आमतौर पर हार्डवेयर सीरियल पोर्ट के लिए आरक्षित हैं)। यह पता लगाने के लिए, आप अपने Arduino बोर्ड को डिस्कनेक्ट कर सकते हैं और मेनू को फिर से खोल सकते हैं, जो प्रविष्टि गायब हो जाती है वह Arduino बोर्ड की होनी चाहिए। बोर्ड को फिर से कनेक्ट करें और उस सीरियल पोर्ट का चयन करें।

Step 8 − Upload the program to your board.

यह समझाने से पहले कि हम अपने कार्यक्रम को बोर्ड पर कैसे अपलोड कर सकते हैं, हमें Arduino IDE टूलबार में दिखाई देने वाले प्रत्येक प्रतीक के कार्य को प्रदर्शित करना चाहिए।

A - यदि कोई संकलित त्रुटि है, तो इसकी जांच करें।

B - एक कार्यक्रम को Arduino बोर्ड पर अपलोड करने के लिए उपयोग किया जाता है।

C - शॉर्टकट एक नया स्केच बनाने के लिए उपयोग किया जाता है।

D - उदाहरण स्केच में से एक को सीधे खोलने के लिए उपयोग किया जाता है।

E - अपने स्केच को बचाने के लिए उपयोग किया जाता है।

F - सीरियल मॉनिटर का उपयोग बोर्ड से सीरियल डेटा प्राप्त करने और सीरियल डेटा को बोर्ड को भेजने के लिए किया जाता है।

अब, बस पर्यावरण में "अपलोड" बटन पर क्लिक करें। कुछ सेकंड प्रतीक्षा करें; आप बोर्ड और फ्लैश पर RX और TX एलईडी देखेंगे। यदि अपलोड सफल होता है, तो संदेश "अपलोड हो गया" स्थिति बार में दिखाई देगा।

Note - यदि आपके पास एक Arduino Mini, NG, या अन्य बोर्ड है, तो आपको Arduino Software पर अपलोड बटन पर क्लिक करने से ठीक पहले बोर्ड पर रीसेट बटन को भौतिक रूप से दबाने की आवश्यकता है।

इस अध्याय में, हम गहराई से अध्ययन करेंगे, Arduino प्रोग्राम संरचना और हम Arduino दुनिया में उपयोग की जाने वाली अधिक नई शब्दावली सीखेंगे। Arduino सॉफ्टवेयर ओपन-सोर्स है। जावा पर्यावरण के लिए स्रोत कोड GPL के तहत जारी किया गया है और C / C ++ माइक्रोकंट्रोलर लाइब्रेरी LGPL के अंतर्गत हैं।

Sketch - पहली नई शब्दावली Arduino प्रोग्राम है जिसे "कहा जाता है"sketch"।

संरचना

Arduino कार्यक्रमों को तीन मुख्य भागों में विभाजित किया जा सकता है: Structure, Values (चर और स्थिरांक), और Functions। इस ट्यूटोरियल में, हम Arduino सॉफ्टवेयर प्रोग्राम, स्टेप बाय स्टेप और हम बिना किसी सिंटैक्स या संकलन त्रुटि के प्रोग्राम कैसे लिख सकते हैं, के बारे में जानेंगे।

हमें इसके साथ शुरू करते हैं Structure। सॉफ्टवेयर संरचना में दो मुख्य कार्य शामिल हैं -

  • सेटअप () फ़ंक्शन
  • लूप () फ़ंक्शन
Void setup ( ) {

}

  • PURPOSE - setup()एक स्केच शुरू होने पर फ़ंक्शन को कहा जाता है। इसका उपयोग वेरिएबल्स, पिन मोड्स, लाइब्रेरीज़ का उपयोग शुरू करने आदि के लिए करें। सेटअप फ़ंक्शन केवल एक बार चलेगा, प्रत्येक पावर अप या Arduino बोर्ड के रीसेट होने के बाद।

  • INPUT - -

  • OUTPUT - -

  • RETURN - -

Void Loop ( ) {

}

  • PURPOSE - बनाने के बाद setup() फ़ंक्शन, जो प्रारंभिक मानों को आरंभ और सेट करता है, loop()फ़ंक्शन ठीक वही करता है जो उसका नाम बताता है, और लगातार लूप करता है, जिससे आपका प्रोग्राम बदल सकता है और प्रतिक्रिया दे सकता है। Arduino बोर्ड को सक्रिय रूप से नियंत्रित करने के लिए इसका उपयोग करें।

  • INPUT - -

  • OUTPUT - -

  • RETURN - -

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

निम्न तालिका सभी डेटा प्रकार प्रदान करती है जिसका उपयोग आप Arduino प्रोग्रामिंग के दौरान करेंगे।

शून्य बूलियन चार अचिन्हित वर्ण बाइट पूर्णांक अहस्ताक्षरित int शब्द
लंबा लंबे समय के बाद कम नाव दोहरा सरणी स्ट्रिंग-चार सरणी स्ट्रिंग-वस्तु

शून्य

शून्य कीवर्ड का उपयोग केवल फ़ंक्शन घोषणाओं में किया जाता है। यह इंगित करता है कि फ़ंक्शन से उस फ़ंक्शन को कोई जानकारी वापस नहीं करने की उम्मीद है, जहां से उसे बुलाया गया था।

उदाहरण

Void Loop ( ) {
   // rest of the code
}

बूलियन

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

उदाहरण

boolean val = false ; // declaration of variable with type boolean and initialize it with false
boolean state = true ; // declaration of variable with type boolean and initialize it with true

चार

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

हालांकि, वर्ण संख्या के रूप में संग्रहीत किए जाते हैं। आप ASCII चार्ट में विशिष्ट एन्कोडिंग देख सकते हैं । इसका मतलब यह है कि पात्रों पर अंकगणित संचालन करना संभव है, जिसमें चरित्र के ASCII मूल्य का उपयोग किया जाता है। उदाहरण के लिए, 'A' + 1 का मान 66 है, क्योंकि कैपिटल अक्षर A का ASCII मान 65 है।

उदाहरण

Char chr_a = ‘a’ ;//declaration of variable with type char and initialize it with character a
Char chr_c = 97 ;//declaration of variable with type char and initialize it with character 97

अचिन्हित वर्ण

Unsigned charएक अहस्ताक्षरित डेटा प्रकार है जो मेमोरी के एक बाइट पर कब्जा कर लेता है। अहस्ताक्षरित चार डेटा प्रकार 0 से 255 तक संख्याओं को एनकोड करता है।

उदाहरण

Unsigned Char chr_y = 121 ; // declaration of variable with type Unsigned char and initialize it with character y

बाइट

एक बाइट 0 से 255 तक 8-बिट अहस्ताक्षरित संख्या को संग्रहीत करता है।

उदाहरण

byte m = 25 ;//declaration of variable with type byte and initialize it with 25

पूर्णांक

नंबर संग्रहण के लिए इंटेगर प्राथमिक डेटा-प्रकार हैं। int 16-बिट (2-बाइट) मान संग्रहीत करता है। यह -32,768 से 32,767 (न्यूनतम मान -2 ^ 15 और अधिकतम मूल्य (2 ^ 15) - 1) की एक श्रेणी देता है।

intआकार बोर्ड से बोर्ड में भिन्न होता है। Arduino ड्यू पर, उदाहरण के लिए, एintएक 32-बिट (4-बाइट) मान संग्रहीत करता है। इससे -2,147,483,648 से 2,147,483,647 (-2 का न्यूनतम मूल्य 31) और अधिकतम मूल्य (2 ^ 31) - 1) प्राप्त होता है।

उदाहरण

int counter = 32 ;// declaration of variable with type int and initialize it with 32

अहस्ताक्षरित int

अनसाइन्टेड इन्टस (अहस्ताक्षरित पूर्णांक) उस तरह से int के समान होते हैं जो वे 2 बाइट मान को संग्रहीत करते हैं। नकारात्मक संख्याओं को संग्रहीत करने के बजाय, हालांकि, वे केवल सकारात्मक मूल्यों को संग्रहीत करते हैं, 0 से 65,535 (2 ^ 16) - 1) की एक उपयोगी श्रेणी की उपज। देय 4 बाइट (32-बिट) मान संग्रहीत करता है, 0 से 4,294,967,295 (2 ^ 32 - 1) तक होता है।

उदाहरण

Unsigned int counter = 60 ; // declaration of variable with 
   type unsigned int and initialize it with 60

शब्द

Uno और अन्य ATMEGA आधारित बोर्डों पर, एक शब्द 16-बिट अहस्ताक्षरित संख्या को संग्रहीत करता है। ड्यू और जीरो पर, यह एक 32-बिट अहस्ताक्षरित संख्या को संग्रहीत करता है।

उदाहरण

word w = 1000 ;//declaration of variable with type word and initialize it with 1000

लंबा

नंबर स्टोरेज के लिए लॉन्ग वैरिएबल का आकार वेरिएबल होता है, और 32 बिट्स (4 बाइट्स) स्टोर करते हैं, -2,147,483,648 से 2,147,483,647 तक।

उदाहरण

Long velocity = 102346 ;//declaration of variable with type Long and initialize it with 102346

अहस्ताक्षरित लंबे

अनसाइन्ड लॉन्ग वैरिएबल को नंबर स्टोरेज के लिए साइज़ वेरिएबल और 32 बिट्स (4 बाइट्स) स्टोर किया जाता है। मानक लोंगो के विपरीत, अहस्ताक्षरित लोंग नकारात्मक संख्याओं को जमा नहीं करेंगे, जिससे उनकी सीमा 0 से 4,294,967,295 (2 ^ 32 - 1) हो जाएगी।

उदाहरण

Unsigned Long velocity = 101006 ;// declaration of variable with 
   type Unsigned Long and initialize it with 101006

कम

एक छोटा 16-बिट डेटा-प्रकार है। सभी Arduinos (ATMega और ARM आधारित) पर, एक छोटा सा 16-बिट (2-बाइट) मान संग्रहीत करता है। यह -32,768 से 32,767 (न्यूनतम मान -2 ^ 15 और अधिकतम मूल्य (2 ^ 15) - 1) की एक श्रेणी देता है।

उदाहरण

short val = 13 ;//declaration of variable with type short and initialize it with 13

नाव

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

फ्लोटिंग-पॉइंट संख्या 3.4028235E + 38 जितनी बड़ी हो सकती है और -3.4028235E + 38 जितनी कम हो सकती है। उन्हें 32 बिट्स (4 बाइट्स) के रूप में संग्रहीत किया जाता है।

उदाहरण

float num = 1.352;//declaration of variable with type float and initialize it with 1.352

दोहरा

Uno और अन्य ATMEGA आधारित बोर्डों पर, डबल सटीक फ़्लोटिंग-पॉइंट नंबर चार बाइट्स रखता है। यही है, डबल कार्यान्वयन बिल्कुल फ्लोट के समान है, जिसमें सटीक रूप से कोई लाभ नहीं है। Arduino ड्यू पर, युगल में 8-बाइट (64 बिट) की सटीकता होती है।

उदाहरण

double num = 45.352 ;// declaration of variable with type double and initialize it with 45.352

इससे पहले कि हम चर प्रकारों की व्याख्या करना शुरू करें, एक बहुत ही महत्वपूर्ण विषय जिसे हमें सुनिश्चित करने की आवश्यकता है, आपको पूरी तरह से समझा जाता है variable scope।

चर स्कोप क्या है?

C प्रोग्रामिंग लैंग्वेज में वेरिएबल्स, जिसे Arduino उपयोग करता है, के पास एक संपत्ति होती है जिसे स्कोप कहा जाता है। एक क्षेत्र कार्यक्रम का एक क्षेत्र है और तीन स्थान हैं जहां चर घोषित किए जा सकते हैं। वे हैं -

  • किसी फ़ंक्शन या ब्लॉक के अंदर, जिसे कहा जाता है local variables।
  • फ़ंक्शन मापदंडों की परिभाषा में, जिसे कहा जाता है formal parameters।
  • सभी कार्यों के बाहर, जिसे कहा जाता है global variables।

स्थानीय चर

किसी फ़ंक्शन या ब्लॉक के अंदर घोषित चर स्थानीय चर हैं। उनका उपयोग केवल उन कथनों द्वारा किया जा सकता है जो उस फ़ंक्शन या कोड के ब्लॉक के अंदर हैं। स्थानीय चर अपने स्वयं के बाहर कार्य करने के लिए ज्ञात नहीं हैं। निम्नलिखित स्थानीय चर का उपयोग करने वाला उदाहरण है -

Void setup () {

}

Void loop () {
   int x , y ;
   int z ; Local variable declaration
   x = 0;
   y = 0; actual initialization
   z = 10;
}

सार्वत्रिक चर

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

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

निम्न उदाहरण वैश्विक और स्थानीय चर का उपयोग करता है -

Int T , S ;
float c = 0 ; Global variable declaration

Void setup () {

}

Void loop () {
   int x , y ;
   int z ; Local variable declaration
   x = 0;
   y = 0; actual initialization
   z = 10;
}

एक ऑपरेटर एक प्रतीक है जो संकलक को विशिष्ट गणितीय या तार्किक कार्य करने के लिए कहता है। C भाषा बिल्ट-इन ऑपरेटरों से समृद्ध है और निम्नलिखित प्रकार के ऑपरेटर प्रदान करती है -

  • अंकगणितीय आपरेटर
  • तुलना संचालक
  • बूलियन ऑपरेटर्स
  • बिटवाइज ऑपरेटर्स
  • यौगिक संचालक

अंकगणितीय आपरेटर

चर A मानें 10 और चर B 20 धारण करता है -

उदाहरण दिखाएँ

ऑपरेटर का नाम संचालक सरल विवरण उदाहरण
असाइनमेंट ऑपरेटर = वैरिएबल में बराबर चिह्न के दाईं ओर के मान को बराबर चिह्न के बाईं ओर संग्रहीत करता है। ए = बी
इसके अलावा + दो ऑपरेंड जोड़ता है A + B 30 देगा
घटाव - पहले से दूसरे ऑपरेंड को घटाता है A - B देगा -10
गुणा * दोनों ऑपरेंड को गुणा करें A * B 200 देगा
विभाजन / भाजक द्वारा अंश को विभाजित करें B / A 2 देगा
सापेक्ष % मापांक ऑपरेटर और पूर्णांक विभाजन के बाद शेष ब% ए द 0 दे खेंगे

तुलना संचालक

चर A मानें 10 और चर B 20 धारण करता है -

उदाहरण दिखाएँ

ऑपरेटर का नाम संचालक सरल विवरण उदाहरण
के बराबर == जाँच करता है कि दो ऑपरेंड का मूल्य बराबर है या नहीं, यदि हाँ तो स्थिति सच हो जाती है। (ए == बी) सच नहीं है
बराबर नही है ! = जाँच करता है कि दो ऑपरेंड का मान बराबर है या नहीं, यदि मान बराबर नहीं हैं तो स्थिति सत्य हो जाती है। (ए! = बी) सच है
से कम < यह जाँचता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से कम है, यदि हाँ, तो स्थिति सही है। (ए <बी) सच है
से अधिक > यह जाँचता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से अधिक है, यदि हाँ, तो स्थिति सत्य है। (ए> बी) सच नहीं है
से कम या बराबर <= जाँच करता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से कम या उसके बराबर है, यदि हाँ तो स्थिति सत्य हो जाती है। (ए <= बी) सच है
इससे बड़ा या इसके बराबर > = जाँच करता है कि क्या बाएं ऑपरेंड का मूल्य सही ऑपरेंड के मूल्य से अधिक या उसके बराबर है, यदि हाँ तो स्थिति सच हो जाती है। (ए> = बी) सच नहीं है

बूलियन ऑपरेटर्स

चर A मानें 10 और चर B 20 धारण करता है -

उदाहरण दिखाएँ

ऑपरेटर का नाम संचालक सरल विवरण उदाहरण
तथा && जिसे लॉजिकल एंड ऑपरेटर कहा जाता है। यदि दोनों ऑपरेशंस गैर-शून्य हैं तो स्थिति सच हो जाती है। (A && B) सत्य है
या || जिसे लॉजिकल या ऑपरेटर कहा जाता है। यदि दोनों संचालकों में से कोई भी गैर-शून्य है तो स्थिति सत्य हो जाती है। (ए || बी) सच है
नहीं ! जिसे लॉजिकल नॉट ऑपरेटर कहा जाता है। उपयोग अपने ऑपरेंड की तार्किक स्थिति को उलट देता है। यदि कोई शर्त सही है तो लॉजिकल नॉट ऑपरेटर गलत साबित करेगा। ! (A && B) गलत है

बिटवाइज ऑपरेटर्स

चर A मानें 60 और चर B 13 धारण करता है -

उदाहरण दिखाएँ

ऑपरेटर का नाम संचालक सरल विवरण उदाहरण
तथा और बाइनरी और ऑपरेटर परिणाम के लिए थोड़ा सा कॉपी करता है यदि यह दोनों ऑपरेंड में मौजूद है। (A & B) 12 देगा जो 0000 1100 है
या | बाइनरी या ऑपरेटर थोड़ा सा कॉपी करता है अगर यह किसी भी ऑपरेंड में मौजूद है (ए | बी) 61 देगा जो 0011 1101 है
XOR ^ बाइनरी एक्सओआर ऑपरेटर बिट को कॉपी करता है यदि यह एक ऑपरेंड में सेट होता है लेकिन दोनों नहीं। (ए ^ बी) 49 देगा जो 0011 0001 है
नहीं ~ बाइनरी ओन्स कंप्लीट ऑपरेटर, एकात्मक है और इसमें 'फ्लिपिंग' बिट्स का प्रभाव होता है। (~ ए) -60 देगा जो 1100 0011 है
शिफ्ट छोड़ दिया << बाइनरी लेफ्ट शिफ्ट ऑपरेटर। बाएं ऑपरेंड वैल्यू को दाएं ऑपरेंड द्वारा निर्दिष्ट बिट्स की संख्या से छोड़ दिया जाता है। A << 2 240 देगा जो 1111 0000 है
सही >> बाइनरी राइट शिफ्ट ऑपरेटर। बाएं ऑपरेंड वैल्यू को दाएं ऑपरेंड द्वारा निर्दिष्ट बिट्स की संख्या से दाएं स्थानांतरित किया जाता है। A >> 2 15 देगा जो 0000 1111 है

यौगिक संचालक

चर A मानें 10 और चर B 20 धारण करता है -

उदाहरण दिखाएँ

ऑपरेटर का नाम संचालक सरल विवरण उदाहरण
वेतन वृद्धि ++ वृद्धि ऑपरेटर, एक के बाद एक पूर्णांक मान बढ़ाता है A ++ 11 देगा
घटती - कमी ऑपरेटर, पूर्णांक मान को एक से कम कर देता है A-- 9 देंगे
यौगिक जोड़ + = जोड़ें और असाइनमेंट ऑपरेटर। यह बाएं ऑपरेंड में दाईं ओर ऑपरेंड जोड़ता है और परिणाम को बाएं ऑपरेंड में असाइन करता है B + = A B = B + A के बराबर है
यौगिक घटाव - = घटाना और असाइनमेंट ऑपरेटर। यह बाएं ऑपरेंड से दाएं ऑपरेंड को घटाता है और लेफ्ट ऑपरेंड को रिजल्ट सौंपता है बी - = ए बी = बी - ए के बराबर है
यौगिक गुणन * = गुणा और असाइनमेंट ऑपरेटर। यह बाएं ऑपरेंड के साथ दाएं ऑपरेंड को गुणा करता है और परिणाम को बाएं ऑपरेंड में असाइन करता है बी * = ए बी = बी * ए के बराबर है
यौगिक विभाजन / = डिवाइड और असाइनमेंट ऑपरेटर। यह बाएं ऑपरेंड को दाएं ऑपरेंड के साथ विभाजित करता है और परिणाम को बाएं ऑपरेंड को सौंपता है बी / = ए बी = बी / ए के बराबर है
यौगिक मोदुलो % = मापांक और असाइनमेंट ऑपरेटर। यह दो ऑपरेंड का उपयोग करके मापांक लेता है और परिणाम को बाएं ऑपरेंड में असाइन करता है बी% = ए बी = बी% ए के बराबर है
यौगिक बिटवेट या | = बिटवाइज समावेशी या असाइनमेंट ऑपरेटर ए | = 2 ए = ए के समान है 2
कंपाउंड बिटवाइज़ और और = बिटवाइज और असाइनमेंट ऑपरेटर A & = 2 A = A & 2 के समान है

निर्णय लेने की संरचनाओं के लिए आवश्यक है कि प्रोग्रामर का मूल्यांकन एक या एक से अधिक शर्तों को निर्धारित किया जाए या प्रोग्राम द्वारा परीक्षण किया जाए। यह एक बयान या कथनों के साथ होना चाहिए, अगर हालत सही हो, और वैकल्पिक रूप से, अन्य स्टेटमेंट्स को निष्पादित किया जाना चाहिए, यदि स्थिति झूठी होने के लिए निर्धारित है।

अधिकांश प्रोग्रामिंग भाषाओं में पाया जाने वाला एक विशिष्ट निर्णय लेने की संरचना का सामान्य रूप निम्नलिखित है -

स्रोत विवरण में नियंत्रण कथन ऐसे तत्व हैं जो प्रोग्राम निष्पादन के प्रवाह को नियंत्रित करते हैं। वे हैं -

क्र.सं. नियंत्रण विवरण और विवरण
1

अगर बयान

यह कोष्ठक में एक अभिव्यक्ति और एक बयान या बयानों का ब्लॉक लेता है। यदि अभिव्यक्ति सही है, तो बयान या बयानों का खंड निष्पादित हो जाता है अन्यथा ये कथन छोड़ दिए जाते हैं।
2

अगर ... और बयान

एक if कथन का अनुसरण वैकल्पिक रूप से किया जा सकता है, जो अभिव्यक्ति के गलत होने पर निष्पादित होता है।
3

अगर ... और अगर ... और बयान

if एक वैकल्पिक बयान का पालन किया जा सकता है else if...else बयान, जो एकल का उपयोग करके विभिन्न स्थितियों का परीक्षण करने के लिए बहुत उपयोगी है अगर ... और यदि कथन।
4

स्विच केस स्टेटमेंट

अगर बयानों के समान, switch...case कार्यक्रमों के प्रवाह को नियंत्रित करता है ताकि प्रोग्रामर विभिन्न कोडों को निर्दिष्ट कर सकें जिन्हें विभिन्न परिस्थितियों में निष्पादित किया जाना चाहिए।
5

सशर्त संचालक :

सशर्त संचालक? : C में एकमात्र टर्नेरी ऑपरेटर है।

प्रोग्रामिंग भाषाएँ विभिन्न नियंत्रण संरचनाएं प्रदान करती हैं जो अधिक जटिल निष्पादन पथों के लिए अनुमति देती हैं।

एक लूप स्टेटमेंट हमें कई बार स्टेटमेंट या स्टेटमेंट को निष्पादित करने की अनुमति देता है और निम्नलिखित प्रोग्रामिंग भाषाओं में से एक लूप स्टेटमेंट का सामान्य रूप है -

सी प्रोग्रामिंग भाषा लूपिंग आवश्यकताओं को संभालने के लिए निम्न प्रकार के लूप प्रदान करती है।

क्र.सं. लूप और विवरण
1

घुमाव के दौरान

जब तक लूप लगातार लूप नहीं करेंगे, और असीम रूप से, जब तक कि कोष्ठक के अंदर की अभिव्यक्ति, () झूठी हो जाती है। कुछ को परीक्षण किए गए चर को बदलना होगा, या जबकि लूप कभी भी बाहर नहीं निकलेगा।
2

करते हैं ... जबकि पाश

do…whileलूप, जबकि लूप के समान है। लूप में, लूप की बॉडी का प्रदर्शन करने से पहले लूप की स्थिति पर लूप की स्थिति का परीक्षण किया जाता है।
3

पाश के लिए

ए for loopबार-बार पूर्व निर्धारित संख्याओं को निष्पादित करता है। लूप के लिए नियंत्रण की अभिव्यक्ति लूप कोष्ठक के लिए पूरी तरह से शुरू, परीक्षण और हेरफेर की जाती है।
4

अंतर प्रविष्ट पाश

सी भाषा आपको एक लूप को दूसरे लूप के अंदर उपयोग करने की अनुमति देती है। निम्नलिखित उदाहरण अवधारणा को दर्शाता है।
5

अनंत लूप

यह लूप है जिसकी कोई समाप्ति स्थिति नहीं है, इसलिए लूप अनंत हो जाता है।

फ़ंक्शंस अलग-अलग कार्य करने के लिए कोड के सेगमेंट में प्रोग्राम को संरचित करने की अनुमति देते हैं। फ़ंक्शन बनाने के लिए विशिष्ट मामला तब होता है जब किसी प्रोग्राम में एक ही क्रिया को कई बार करने की आवश्यकता होती है।

फ़ंक्शंस में मानकीकरण कोड के कई फायदे हैं -

  • फ़ंक्शंस प्रोग्रामर को व्यवस्थित रहने में मदद करते हैं। अक्सर यह कार्यक्रम को अवधारणा बनाने में मदद करता है।

  • फ़ंक्शंस एक स्थान पर एक क्रिया को संहिताबद्ध करते हैं ताकि फ़ंक्शन को केवल एक बार सोचना और डीबग करना पड़े।

  • यह संशोधन में त्रुटियों की संभावना को भी कम करता है, अगर कोड को बदलना होगा।

  • फ़ंक्शंस पूरे स्केच को छोटा और अधिक कॉम्पैक्ट बनाते हैं क्योंकि कई बार कोड के पुन: उपयोग किए जाते हैं।

  • वे इसे मॉड्यूलर बनाकर अन्य कार्यक्रमों में कोड का पुन: उपयोग करना आसान बनाते हैं, और फ़ंक्शन का उपयोग करते हुए अक्सर कोड को अधिक पठनीय बनाते हैं।

एक Arduino स्केच या एक कार्यक्रम यानी सेटअप () और लूप () में दो आवश्यक कार्य हैं। अन्य कार्यों को इन दो कार्यों के कोष्ठक के बाहर बनाया जाना चाहिए।

किसी फ़ंक्शन को परिभाषित करने के लिए सबसे आम सिंटैक्स है -

समारोह घोषणा

एक फ़ंक्शन किसी अन्य फ़ंक्शन के बाहर, लूप फ़ंक्शन के ऊपर या नीचे घोषित किया जाता है।

हम फ़ंक्शन को दो अलग-अलग तरीकों से घोषित कर सकते हैं -

पहला तरीका केवल फ़ंक्शन के भाग को लिख रहा है जिसे कहा जाता है a function prototype लूप फ़ंक्शन के ऊपर, जिसमें निम्न शामिल हैं -

  • फ़ंक्शन वापसी प्रकार
  • कार्य का नाम
  • फ़ंक्शन तर्क प्रकार, तर्क नाम लिखने की आवश्यकता नहीं है

फ़ंक्शन प्रोटोटाइप को अर्धविराम (;) द्वारा अनुसरण किया जाना चाहिए।

निम्न उदाहरण पहले विधि का उपयोग करके फ़ंक्शन घोषणा के प्रदर्शन को दर्शाता है।

उदाहरण

int sum_func (int x, int y) // function declaration {
   int z = 0;
   z = x+y ;
   return z; // return the value
}

void setup () {
   Statements // group of statements
}

Void loop () {
   int result = 0 ;
   result = Sum_func (5,6) ; // function call
}

दूसरा भाग, जिसे फंक्शन डेफिनेशन या डिक्लेरेशन कहा जाता है, को लूप फंक्शन से नीचे घोषित किया जाना चाहिए, जिसमें शामिल हैं -

  • फ़ंक्शन वापसी प्रकार
  • कार्य का नाम
  • फ़ंक्शन तर्क प्रकार, यहां आपको तर्क नाम जोड़ना होगा
  • फ़ंक्शन बॉडी (फ़ंक्शन को कॉल करने पर फ़ंक्शन के अंदर स्टेटमेंट्स)

निम्नलिखित उदाहरण दूसरी विधि का उपयोग करके फ़ंक्शन की घोषणा को दर्शाता है।

उदाहरण

int sum_func (int , int ) ; // function prototype

void setup () {
   Statements // group of statements
}

Void loop () {
   int result = 0 ;
   result = Sum_func (5,6) ; // function call
}

int sum_func (int x, int y) // function declaration {
   int z = 0;
   z = x+y ;
   return z; // return the value
}

दूसरी विधि सिर्फ लूप फ़ंक्शन के ऊपर फ़ंक्शन को घोषित करती है।

पाठ को संग्रहीत करने के लिए स्ट्रिंग्स का उपयोग किया जाता है। उनका उपयोग एलसीडी पर या Arduino IDE सीरियल मॉनिटर विंडो में टेक्स्ट प्रदर्शित करने के लिए किया जा सकता है। उपयोगकर्ता इनपुट को संग्रहीत करने के लिए स्ट्रिंग्स भी उपयोगी हैं। उदाहरण के लिए, वर्ण जो उपयोगकर्ता Arduino से जुड़े कीपैड पर टाइप करते हैं।

Arduino प्रोग्रामिंग में दो प्रकार के तार हैं -

  • वर्णों की सारणियाँ, जो C प्रोग्रामिंग में प्रयुक्त स्ट्रिंग्स के समान हैं।
  • Arduino स्ट्रिंग, जो हमें स्केच में एक स्ट्रिंग ऑब्जेक्ट का उपयोग करने देता है।

इस अध्याय में, हम स्ट्रिंग्स, वस्तुओं और अरुडिनो स्केच में स्ट्रिंग्स के उपयोग को सीखेंगे। अध्याय के अंत तक, आप सीखेंगे कि स्केच में किस प्रकार के स्ट्रिंग का उपयोग करना है।

स्ट्रिंग चरित्र

पहली प्रकार की स्ट्रिंग जो हम सीखेंगे वह स्ट्रिंग है जो कि प्रकार के पात्रों की एक श्रृंखला है char। पिछले अध्याय में, हमने सीखा कि एक सरणी क्या है; मेमोरी में संग्रहीत एक ही प्रकार के चर की एक निरंतर श्रृंखला। एक स्ट्रिंग चार चर का एक सरणी है।

एक स्ट्रिंग एक विशेष सरणी है जिसमें स्ट्रिंग के अंत में एक अतिरिक्त तत्व होता है, जिसमें हमेशा 0 (शून्य) का मान होता है। इसे "नल समाप्त स्ट्रिंग" के रूप में जाना जाता है।

स्ट्रिंग चरित्र सरणी उदाहरण

यह उदाहरण दिखाएगा कि कैसे एक स्ट्रिंग बनाने के लिए और इसे सीरियल मॉनिटर विंडो पर प्रिंट करें।

Example

void setup() {
   char my_str[6]; // an array big enough for a 5 character string
   Serial.begin(9600);
   my_str[0] = 'H'; // the string consists of 5 characters
   my_str[1] = 'e';
   my_str[2] = 'l';
   my_str[3] = 'l';
   my_str[4] = 'o';
   my_str[5] = 0; // 6th array element is a null terminator
   Serial.println(my_str);
}

void loop() { 

}

निम्नलिखित उदाहरण से पता चलता है कि स्ट्रिंग किस चीज से बनी है; मुद्रण योग्य वर्णों के साथ एक वर्ण सरणी और सरणी के अंतिम तत्व के रूप में 0 यह दिखाने के लिए कि यह वह जगह है जहाँ स्ट्रिंग समाप्त होती है। स्ट्रिंग को Arduino IDE Serial Monitor विंडो का उपयोग करके प्रिंट किया जा सकता हैSerial.println() और स्ट्रिंग का नाम गुजर रहा है।

यह एक ही उदाहरण एक और अधिक सुविधाजनक तरीके से लिखा जा सकता है जैसा कि नीचे दिखाया गया है -

Example

void setup() {
   char my_str[] = "Hello";
   Serial.begin(9600);
   Serial.println(my_str);
}

void loop() {

}

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

स्ट्रिंग एरर को मैनिप्युलेट करना

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

उदाहरण

void setup() {
   char like[] = "I like coffee and cake"; // create a string
   Serial.begin(9600);
   // (1) print the string
   Serial.println(like);
   // (2) delete part of the string
   like[13] = 0;
   Serial.println(like);
   // (3) substitute a word into the string
   like[13] = ' '; // replace the null terminator with a space
   like[18] = 't'; // insert the new word
   like[19] = 'e';
   like[20] = 'a';
   like[21] = 0; // terminate the string
   Serial.println(like);
}

void loop() {

}

परिणाम

I like coffee and cake
I like coffee
I like coffee and tea

स्केच निम्नलिखित तरीके से काम करता है।

स्ट्रिंग बनाना और प्रिंट करना

ऊपर दिए गए स्केच में, एक नया स्ट्रिंग बनाया जाता है और फिर सीरियल मॉनिटर विंडो में प्रदर्शन के लिए मुद्रित किया जाता है।

स्ट्रिंग को छोटा करना

स्ट्रिंग में 14 वें चरित्र को शून्य शून्य (2) के साथ बदलकर स्ट्रिंग को छोटा किया जाता है। यह 0 से स्ट्रिंग की गिनती में तत्व संख्या 13 है।

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

स्ट्रिंग में एक शब्द बदलना

अंत में, स्केच "केक" शब्द को "चाय" (3) से बदल देता है। इसे सबसे पहले अशक्त टर्मिनेटर को बदलना है जैसे कि [13] एक स्थान के साथ ताकि स्ट्रिंग मूल रूप से बनाए गए प्रारूप में बहाल हो।

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

स्ट्रिंग एरर को मैनिपुलेट करने के लिए कार्य

पिछले स्केच ने स्ट्रिंग में अलग-अलग पात्रों को एक्सेस करके मैन्युअल तरीके से स्ट्रिंग में हेरफेर किया। स्ट्रिंग सरणियों में हेरफेर करना आसान बनाने के लिए, आप ऐसा करने के लिए अपने स्वयं के कार्य लिख सकते हैं, या इसमें से कुछ स्ट्रिंग फ़ंक्शन का उपयोग कर सकते हैंC भाषा पुस्तकालय।

क्र.सं. कार्य और विवरण
1

String()

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

संदर्भ के लिए, वर्ण सरणियों को एक छोटे 'एस' के साथ तार के रूप में संदर्भित किया जाता है, और स्ट्रिंग वर्ग के उदाहरणों को एक पूंजी एस के साथ स्ट्रिंग्स के रूप में संदर्भित किया जाता है। ध्यान दें कि "डबल कोट्स" में निर्दिष्ट निरंतर तार को चार सरणियों के रूप में माना जाता है, स्ट्रिंग वर्ग के उदाहरण नहीं
2

charAt()

स्ट्रिंग के किसी विशेष वर्ण तक पहुँचें।
3

compareTo()

दो स्ट्रिंग्स की तुलना करता है, परीक्षण करता है कि क्या एक दूसरे से पहले या बाद में आता है, या क्या वे समान हैं। तार चरित्र के ASCII मूल्यों का उपयोग करके चरित्र द्वारा तुलना की जाती है। इसका मतलब है, उदाहरण के लिए, 'ए' 'बी' से पहले आता है लेकिन 'ए' के ​​बाद। अक्षर से पहले नंबर आते हैं।
4

concat()

पैरामीटर को स्ट्रिंग पर लागू करता है।
5

c_str()

एक स्ट्रिंग की सामग्री को सी-स्टाइल, अशक्त-समाप्त स्ट्रिंग के रूप में परिवर्तित करता है। ध्यान दें कि यह आंतरिक स्ट्रिंग बफर को सीधे एक्सेस देता है और इसका उपयोग देखभाल के साथ किया जाना चाहिए। विशेष रूप से, आपको कभी भी दिए गए पॉइंटर के माध्यम से स्ट्रिंग को संशोधित नहीं करना चाहिए। जब आप स्ट्रिंग ऑब्जेक्ट को संशोधित करते हैं, या जब यह नष्ट हो जाता है, तो पहले से c_str () द्वारा लौटाया गया कोई भी सूचक अमान्य हो जाता है और इसे अब उपयोग नहीं किया जाना चाहिए।
6

endsWith()

परीक्षण एक स्ट्रिंग के दूसरे स्ट्रिंग के पात्रों के साथ समाप्त होता है या नहीं।
7

equals()

समानता के लिए दो तारों की तुलना करता है। तुलना केस-संवेदी है, जिसका अर्थ है स्ट्रिंग "हैलो" स्ट्रिंग "हेलो" के बराबर नहीं है।
8

equalsIgnoreCase()

समानता के लिए दो तारों की तुलना करता है। तुलना मामले के प्रति संवेदनशील नहीं है, जिसका अर्थ है स्ट्रिंग ("हैलो") स्ट्रिंग ("हेलो") के बराबर है।
9

getBytes()

आपूर्ति किए गए बफर को स्ट्रिंग के पात्रों की प्रतिलिपि बनाता है।
10

indexOf()

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

lastIndexOf()

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

length()

स्ट्रिंग की लंबाई, वर्णों में देता है। (ध्यान दें कि इसमें अनुगामी अशक्त वर्ण शामिल नहीं है।)
13

remove()

जगह में संशोधित करें, एक स्ट्रिंग को प्रदान किए गए इंडेक्स से स्ट्रिंग के अंत तक या प्रदान किए गए इंडेक्स से इंडेक्स प्लस काउंट तक चार्ट हटाने।
14

replace()

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

reserve()

स्ट्रिंग रिजर्व () फ़ंक्शन आपको स्ट्रिंग्स में हेरफेर करने के लिए मेमोरी में एक बफर आवंटित करने की अनुमति देता है।
16

setCharAt()

स्ट्रिंग का एक चरित्र सेट करता है। स्ट्रिंग की मौजूदा लंबाई के बाहर सूचकांकों पर कोई प्रभाव नहीं है।
17

startsWith()

परीक्षण एक स्ट्रिंग के दूसरे स्ट्रिंग के पात्रों के साथ शुरू होता है या नहीं।
18

toCharArray()

आपूर्ति किए गए बफर को स्ट्रिंग के पात्रों की प्रतिलिपि बनाता है।
19

substring()

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

toInt()

एक मान्य स्ट्रिंग को पूर्णांक में परिवर्तित करता है। इनपुट स्ट्रिंग एक पूर्णांक संख्या से शुरू होनी चाहिए। यदि स्ट्रिंग में गैर-पूर्णांक संख्याएं हैं, तो फ़ंक्शन रूपांतरण करना बंद कर देगा।
21

toFloat()

एक मान्य स्ट्रिंग को एक फ़्लोट में परिवर्तित करता है। इनपुट स्ट्रिंग एक अंक से शुरू होनी चाहिए। यदि स्ट्रिंग में गैर-अंक वर्ण हैं, तो फ़ंक्शन रूपांतरण करना बंद कर देगा। उदाहरण के लिए, स्ट्रिंग्स "123.45", "123", और "123fish" क्रमशः 123.45, 123.00 और 123.00 में परिवर्तित हो जाते हैं। ध्यान दें कि "123.456" 123.46 के साथ अनुमानित है। यह भी ध्यान दें कि तैरने में सटीकता के केवल 6-7 दशमलव अंक होते हैं और इससे लंबे तार काटे जा सकते हैं।
22

toLowerCase()

एक स्ट्रिंग का निचला-केस संस्करण प्राप्त करें। 1.0 के रूप में, toLowerCase () एक नए को वापस करने के बजाय जगह में स्ट्रिंग को संशोधित करता है।
23

toUpperCase()

स्ट्रिंग का ऊपरी-केस संस्करण प्राप्त करें। 1.0 के रूप में, toUpperCase () एक नए को वापस करने के बजाय जगह में स्ट्रिंग को संशोधित करता है।
24

trim()

निकाले गए किसी भी अग्रणी और अनुगामी व्हाट्सएप के साथ स्ट्रिंग का एक संस्करण प्राप्त करें। 1.0 के रूप में, ट्रिम () एक नया लौटने के बजाय स्ट्रिंग को संशोधित करता है।

अगले स्केच में कुछ सी स्ट्रिंग फ़ंक्शन का उपयोग किया गया है।

उदाहरण

void setup() {
   char str[] = "This is my string"; // create a string
   char out_str[40]; // output from string functions placed here
   int num; // general purpose integer
   Serial.begin(9600);

   // (1) print the string
   Serial.println(str);

   // (2) get the length of the string (excludes null terminator)
   num = strlen(str);
   Serial.print("String length is: ");
   Serial.println(num);

   // (3) get the length of the array (includes null terminator)
   num = sizeof(str); // sizeof() is not a C string function
   Serial.print("Size of the array: ");
   Serial.println(num);

   // (4) copy a string
   strcpy(out_str, str);
   Serial.println(out_str);

   // (5) add a string to the end of a string (append)
   strcat(out_str, " sketch.");
   Serial.println(out_str);
   num = strlen(out_str);
   Serial.print("String length is: ");
   Serial.println(num);
   num = sizeof(out_str);
   Serial.print("Size of the array out_str[]: ");
   Serial.println(num);
}

void loop() {

}

परिणाम

This is my string
String length is: 17
Size of the array: 18
This is my string
This is my string sketch.
String length is: 25
Size of the array out_str[]: 40

स्केच निम्नलिखित तरीके से काम करता है।

स्ट्रिंग प्रिंट करें

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

स्ट्रिंग की लंबाई प्राप्त करें

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

स्ट्रिंग में 17 अक्षर हैं, इसलिए हम 17 को सीरियल मॉनीटर विंडो में प्रिंट करते हुए देखते हैं।

ऐरे की लंबाई प्राप्त करें

ऑपरेटर आकार () का उपयोग उस स्ट्रिंग की लंबाई प्राप्त करने के लिए किया जाता है जिसमें स्ट्रिंग शामिल है। लंबाई में शून्य टर्मिनेटर शामिल है, इसलिए लंबाई स्ट्रिंग की लंबाई से एक अधिक है।

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

एक स्ट्रिंग की प्रतिलिपि बनाएँ

Strcpy () फ़ंक्शन का उपयोग str [] स्ट्रिंग को out_num [] सरणी में कॉपी करने के लिए किया जाता है। Strcpy () फ़ंक्शन की प्रतिलिपि दूसरी स्ट्रिंग को पहले स्ट्रिंग में दी गई है। स्ट्रिंग की एक प्रति अब out_num [] सरणी में मौजूद है, लेकिन केवल सरणी के 18 तत्वों को लेती है, इसलिए हमारे पास अभी भी सरणी में 22 मुक्त चार तत्व हैं। ये मुक्त तत्व स्मृति में स्ट्रिंग के बाद पाए जाते हैं।

स्ट्रिंग को सरणी में कॉपी किया गया था ताकि स्केच के अगले भाग में उपयोग करने के लिए हमारे पास सरणी में कुछ अतिरिक्त स्थान हो, जो स्ट्रिंग के अंत में एक स्ट्रिंग जोड़ रहा है।

स्ट्रिंग को एक स्ट्रिंग में जोड़ें (कॉनटेननेट)

स्केच एक स्ट्रिंग से दूसरे में जुड़ता है, जिसे कॉन्टेक्टेशन के रूप में जाना जाता है। यह स्ट्रैकट () फ़ंक्शन का उपयोग करके किया जाता है। Strcat () फ़ंक्शन इसके द्वारा पास किए गए पहले स्ट्रिंग के अंत में पास किए गए दूसरे स्ट्रिंग को डालता है।

संघनन के बाद, नई स्ट्रिंग की लंबाई दिखाने के लिए स्ट्रिंग की लंबाई मुद्रित की जाती है। सरणी की लंबाई तब यह दिखाने के लिए मुद्रित की जाती है कि हमारे पास 40-तत्व लंबे सरणी में 25-वर्ण लंबा स्ट्रिंग है।

याद रखें कि 25-वर्ण लंबा स्ट्रिंग वास्तव में शून्य समाप्त होने के कारण सरणी के 26 वर्णों को लेता है।

ऐरे की सीमा

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

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

Arduino प्रोग्रामिंग में प्रयुक्त दूसरे प्रकार की स्ट्रिंग String Object है।

एक वस्तु क्या है?

एक ऑब्जेक्ट एक निर्माण है जिसमें डेटा और फ़ंक्शन दोनों शामिल हैं। एक स्ट्रिंग ऑब्जेक्ट को एक चर की तरह बनाया जा सकता है और एक मान या स्ट्रिंग निर्दिष्ट किया जा सकता है। स्ट्रिंग ऑब्जेक्ट में फ़ंक्शन (ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (OOP) में "तरीके" कहा जाता है) जो स्ट्रिंग ऑब्जेक्ट में निहित स्ट्रिंग डेटा पर काम करते हैं।

निम्नलिखित स्केच और स्पष्टीकरण से यह स्पष्ट हो जाएगा कि कोई वस्तु क्या है और स्ट्रिंग ऑब्जेक्ट का उपयोग कैसे किया जाता है।

उदाहरण

void setup() { 
   String my_str = "This is my string.";
   Serial.begin(9600);

   // (1) print the string
   Serial.println(my_str);

   // (2) change the string to upper-case
   my_str.toUpperCase();
   Serial.println(my_str);

   // (3) overwrite the string
   my_str = "My new string.";
   Serial.println(my_str);

   // (4) replace a word in the string
   my_str.replace("string", "Arduino sketch");
   Serial.println(my_str);

   // (5) get the length of the string
   Serial.print("String length is: ");
   Serial.println(my_str.length());
}

void loop() { 

}

परिणाम

This is my string.
THIS IS MY STRING.
My new string.
My new Arduino sketch.
String length is: 22

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

String my_str = "This is my string." ;

यह नाम के साथ एक स्ट्रिंग ऑब्जेक्ट बनाता है my_str और इसे "यह मेरा तार है।"

इसकी तुलना एक वैरिएबल बनाने और एक मान को निर्दिष्ट करने के लिए की जा सकती है जैसे कि पूर्णांक -

int my_var = 102;

स्केच निम्नलिखित तरीके से काम करता है।

स्ट्रिंग मुद्रण

स्ट्रिंग को कैरेक्टर मॉनिटर स्ट्रिंग की तरह ही सीरियल मॉनिटर विंडो में प्रिंट किया जा सकता है।

स्ट्रिंग को अपर-केस में कनवर्ट करें

स्ट्रिंग ऑब्जेक्ट my_str जो बनाया गया था, इसमें कई फ़ंक्शन या विधियाँ हैं, जिन्हें इस पर संचालित किया जा सकता है। इन विधियों को डॉट ऑपरेटर (।) और फिर उपयोग करने के लिए फ़ंक्शन के नाम के बाद ऑब्जेक्ट नाम का उपयोग करके लागू किया जाता है।

my_str.toUpperCase();

toUpperCase() समारोह में निहित स्ट्रिंग पर चल रही है my_strऑब्जेक्ट जो स्ट्रिंग का प्रकार है और स्ट्रिंग डेटा (या पाठ) को कनवर्ट करता है, जिसमें ऑब्जेक्ट ऊपरी मामले के पात्रों में शामिल है। स्ट्रिंगिंग वर्ग में होने वाले कार्यों की एक सूची Arduino स्ट्रिंग संदर्भ में पाई जा सकती है। तकनीकी रूप से, स्ट्रिंग को एक वर्ग कहा जाता है और इसका उपयोग स्ट्रिंग ऑब्जेक्ट बनाने के लिए किया जाता है।

एक स्ट्रिंग को अधिलेखित करें

असाइनमेंट ऑपरेटर का उपयोग नए स्ट्रिंग को असाइन करने के लिए किया जाता है my_str ऑब्जेक्ट जो पुराने स्ट्रिंग को बदलता है

my_str = "My new string." ;

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

स्ट्रिंग में एक शब्द की जगह

प्रतिस्थापित () फ़ंक्शन का उपयोग पहली स्ट्रिंग को उसके पास करने के लिए किया जाता है, दूसरे स्ट्रिंग द्वारा इसे पास किया जाता है। प्रतिस्थापित () एक और फ़ंक्शन है जो स्ट्रिंग वर्ग में बनाया गया है और इसलिए स्ट्रिंग ऑब्जेक्ट my_str पर उपयोग करने के लिए उपलब्ध है।

स्ट्रिंग की लंबाई हो रही है

स्ट्रिंग की लंबाई प्राप्त करना आसानी से लंबाई () का उपयोग करके किया जाता है। उदाहरण स्केच में, लंबाई () द्वारा लौटाए गए परिणाम को सीधे एक मध्यवर्ती चर का उपयोग किए बिना Serial.println () में पारित किया जाता है।

जब एक स्ट्रिंग वस्तु का उपयोग करने के लिए

स्ट्रिंग वर्ण सरणी की तुलना में स्ट्रिंग ऑब्जेक्ट का उपयोग करना बहुत आसान है। ऑब्जेक्ट में अंतर्निहित कार्य हैं जो स्ट्रिंग्स पर कई ऑपरेशन कर सकते हैं।

स्ट्रिंग ऑब्जेक्ट का उपयोग करने का मुख्य नुकसान यह है कि यह बहुत अधिक मेमोरी का उपयोग करता है और जल्दी से Arduinos RAM मेमोरी का उपयोग कर सकता है, जिसके कारण Arduino लटका, क्रैश या अप्रत्याशित रूप से व्यवहार कर सकता है। यदि एक Arduino पर एक स्केच छोटा है और वस्तुओं के उपयोग को सीमित करता है, तो कोई समस्या नहीं होनी चाहिए।

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

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

जहां स्ट्रिंग्स का उपयोग किया जाता है

इस अध्याय में हमने स्ट्रिंग्स के बारे में अध्ययन किया कि वे स्मृति और उनके संचालन में कैसे व्यवहार करते हैं।

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

Arduino चार अलग-अलग समय हेरफेर फ़ंक्शन प्रदान करता है। वे हैं -

क्र.सं. समारोह विवरण
1

देरी () समारोह

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

देरीमाइक्रोसेकंड () फ़ंक्शन

delayMicroseconds()फ़ंक्शन एक पूर्णांक (या संख्या) तर्क को स्वीकार करता है। एक मिलीसेकंड में एक हजार माइक्रोसेकंड होते हैं, और एक सेकंड में एक लाख माइक्रोसेकंड।
3

मिलिस () फ़ंक्शन

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

micros () फ़ंक्शन

माइक्रोस () फ़ंक्शन समय से माइक्रोसेकंड की संख्या लौटाता है, अरुडिनो बोर्ड वर्तमान कार्यक्रम चलाना शुरू कर देता है। लगभग 70 मिनट के बाद यह संख्या ओवरफ्लो हो जाती है।

एक सरणी स्मृति स्थानों का एक निरंतर समूह है जो एक ही प्रकार का होता है। सरणी में किसी विशेष स्थान या तत्व को संदर्भित करने के लिए, हम सरणी में नाम और विशेष तत्व की स्थिति संख्या का नाम निर्दिष्ट करते हैं।

नीचे दिया गया चित्रण एक पूर्णांक सरणी दिखाता है जिसे C कहा जाता है जिसमें 11 तत्व होते हैं। आप वर्ग ब्रैकेट ([]) में विशेष तत्व की स्थिति संख्या के बाद सरणी नाम देकर इन तत्वों में से किसी एक का उल्लेख करते हैं। स्थिति संख्या को औपचारिक रूप से सबस्क्रिप्ट या इंडेक्स कहा जाता है (यह संख्या सरणी की शुरुआत से तत्वों की संख्या को निर्दिष्ट करती है)। पहले तत्व की सबस्क्रिप्ट 0 (शून्य) है और कभी-कभी इसे शून्य तत्व कहा जाता है।

इस प्रकार, सरणी C के तत्व C [0] ("C उप शून्य"), C [1], C [2] इत्यादि हैं। सरणी C में उच्चतम सबस्क्रिप्ट 10 है, जो कि सरणी (11) में तत्वों की संख्या से 1 कम है। सरणी नाम अन्य चर नामों के समान सम्मेलनों का पालन करते हैं।

एक सबस्क्रिप्ट एक पूर्णांक या पूर्णांक अभिव्यक्ति (किसी भी अभिन्न प्रकार का उपयोग करके) होना चाहिए। यदि कोई प्रोग्राम किसी अभिव्यक्ति को सबस्क्रिप्ट के रूप में उपयोग करता है, तो प्रोग्राम सबस्क्रिप्ट को निर्धारित करने के लिए अभिव्यक्ति का मूल्यांकन करता है। उदाहरण के लिए, यदि हम मानते हैं कि चर a 5 के बराबर है और चर b 6 के बराबर है, तो कथन 2 से सरणी तत्व C [11] को जोड़ता है।

एक उप-सुव्यवस्थित सरणी नाम एक लवल्यू है, इसे एक असाइनमेंट के बाईं ओर इस्तेमाल किया जा सकता है, ठीक उसी तरह जैसे कि गैर-ऐरे वेरिएबल कर सकता है।

आइए दिए गए चित्र में सरणी C की अधिक बारीकी से जांच करें। संपूर्ण सरणी का नाम C. है। इसके 11 तत्वों को C [0] से C [10] कहा जाता है। C [0] का मान -45 है, C [1] का मान 6 है, C [2] का मान 0 है, C [7] का मान 62 है, और C [10] का मूल्य है 78।

सरणी C के पहले तीन तत्वों में निहित मूल्यों का योग प्रिंट करने के लिए, हम लिखेंगे -

Serial.print (C[ 0 ] + C[ 1 ] + C[ 2 ] );

C [6] के मान को 2 से भाग देने और परिणाम को चर x में निर्दिष्ट करने के लिए, हम लिखेंगे -

x = C[ 6 ] / 2;

घोषणाएँ

स्मृति में जगह घेरती है। किसी सरणी द्वारा आवश्यक तत्वों के प्रकार और तत्वों की संख्या निर्दिष्ट करने के लिए, फॉर्म की घोषणा का उपयोग करें -

type arrayName [ arraySize ] ;

संकलक स्मृति की उचित मात्रा को सुरक्षित रखता है। (स्मरण करो कि एक घोषणा, जो स्मृति को अधिक ठीक से परिभाषा के रूप में जाना जाता है)। ArraySize शून्य से अधिक पूर्णांक स्थिर होना चाहिए। उदाहरण के लिए, पूर्णांक सरणी C के लिए 11 तत्वों को आरक्षित करने के लिए संकलक को बताना, घोषणा का उपयोग करना -

int C[ 12 ]; // C is an array of 12 integers

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

Arrays का उपयोग करते हुए उदाहरण

यह खंड कई उदाहरण देता है जो एरे को घोषित करने, शुरू करने और हेरफेर करने का तरीका प्रदर्शित करता है।

उदाहरण 1: एक ऐरे की घोषणा करना और ऐरे के तत्वों को शुरू करने के लिए एक लूप का उपयोग करना

कार्यक्रम 10-तत्व पूर्णांक सरणी घोषित करता है n। लाइन्स a-b उपयोग aForसरणी तत्वों को शून्य करने के लिए प्रारंभिक विवरण। अन्य स्वचालित चर की तरह, स्वचालित सरणियों को शून्य से प्रारंभिक रूप से आरंभ नहीं किया जाता है। पहला आउटपुट स्टेटमेंट (लाइन c) स्टेटमेंट (लाइनें d – e) के लिए बाद में छपे कॉलम के कॉलम कॉलम को प्रदर्शित करता है, जो सारणीबद्ध सारणी में सरणी को प्रिंट करता है।

Example

int n[ 10 ] ; // n is an array of 10 integers

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) // initialize elements of array n to 0 {
      n[ i ] = 0; // set element at location i to 0
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}

Result - यह निम्नलिखित परिणाम का उत्पादन करेगा -

 
       
        
 
         Element 
         Value 
        
 
        
 
          
0
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 		 
          
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0
 
0

उदाहरण 2: एक प्रारंभिक सूची के साथ घोषणा में एक ऐरे को प्रारंभ करना

किसी ऐरे के तत्वों को ऐरे-नेम में एक समान-चिह्न के साथ और ब्रेस-सीमांकित अल्पविराम से अलग की गई इनिशियल्स की सूची का अनुसरण करके ऐरे घोषणा में आरंभीकृत किया जा सकता है। यह प्रोग्राम 10 मानों (लाइन) के साथ पूर्णांक सरणी को आरंभीकृत करने के लिए एक प्रारंभिक सूची का उपयोग करता है और सारणी को सारणीबद्ध प्रारूप (पंक्तियों b-c) में मुद्रित करता है।

Example

// n is an array of 10 integers
int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 } ;

void setup () {

}

void loop () {
   for ( int i = 0; i < 10; ++i ) {
      Serial.print (i) ;
      Serial.print (‘\r’) ;
   }
   for ( int j = 0; j < 10; ++j ) // output each array element's value {
      Serial.print (n[j]) ;
      Serial.print (‘\r’) ;
   } 
}

Result - यह निम्नलिखित परिणाम का उत्पादन करेगा -

 
       
        
 
         Element 
         Value 
        
 
        
 
          
0
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 		 
          
32
 
27
 
64
 
18
 
95
 
14
 
90
 
70
 
60
 
37

उदाहरण 3: एक तत्व का सारांश

अक्सर, एक सरणी के तत्व गणना में उपयोग किए जाने वाले मूल्यों की एक श्रृंखला का प्रतिनिधित्व करते हैं। उदाहरण के लिए, यदि एरे के तत्व परीक्षा के ग्रेड का प्रतिनिधित्व करते हैं, तो एक प्रोफेसर एरे के तत्वों को टाल सकता है और परीक्षा के लिए कक्षा के औसत की गणना करने के लिए उस राशि का उपयोग कर सकता है। कार्यक्रम में 10-तत्व पूर्णांक सरणी में निहित मान हैंa।

Example

const int arraySize = 10; // constant variable indicating size of array
int a[ arraySize ] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
int total = 0;

void setup () {

}
void loop () {
   // sum contents of array a
   for ( int i = 0; i < arraySize; ++i )
      total += a[ i ];
   Serial.print (“Total of array elements : ”) ;
   Serial.print(total) ;
}

Result - यह निम्नलिखित परिणाम का उत्पादन करेगा -

Total of array elements: 849

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

क्र.सं. अवधारणा और विवरण
1 कार्य करने के लिए Arrays पास करना

किसी फ़ंक्शन के लिए एक सरणी तर्क पास करने के लिए, किसी भी कोष्ठक के बिना सरणी का नाम निर्दिष्ट करें।
2 मल्टी-डायमेंशनल एरे

दो आयामों (यानी, सदस्यता) के साथ पहुंच अक्सर मानों की तालिकाओं का प्रतिनिधित्व करती है जिसमें पंक्तियों और स्तंभों में व्यवस्थित जानकारी होती है।

Arduino बोर्ड पर पिन को इनपुट या आउटपुट के रूप में कॉन्फ़िगर किया जा सकता है। हम उन मोड में पिंस के कामकाज की व्याख्या करेंगे। यह ध्यान रखना महत्वपूर्ण है कि Arduino एनालॉग पिंस का बहुमत, डिजिटल पिंस के रूप में बिल्कुल उसी तरीके से कॉन्फ़िगर और उपयोग किया जा सकता है।

पिन INPUT के रूप में कॉन्फ़िगर किए गए

Arduino पिन डिफ़ॉल्ट रूप से इनपुट के रूप में कॉन्फ़िगर किए गए हैं, इसलिए उन्हें इनपुट के साथ स्पष्ट रूप से घोषित किए जाने की आवश्यकता नहीं है pinMode()जब आप उन्हें इनपुट के रूप में उपयोग कर रहे हैं। इस तरह से कॉन्फ़िगर किए गए पिंस को उच्च-प्रतिबाधा स्थिति में कहा जाता है। इनपुट पिन सर्किट पर बेहद छोटी मांग करते हैं कि वे नमूना ले रहे हैं, पिन के सामने 100 मेगाहीम के एक श्रृंखला रोकनेवाला के बराबर।

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

पिन को पिनमोड (पिन, INPUT) के रूप में कॉन्फ़िगर किया गया है, उनके साथ जुड़ा हुआ कुछ भी नहीं है, या उनके साथ जुड़े तारों के साथ जो अन्य सर्किट से जुड़े नहीं हैं, पिन राज्य में उल्लेखनीय रूप से यादृच्छिक परिवर्तन रिपोर्ट करते हैं, पर्यावरण से विद्युत शोर उठाते हैं, या कैपेसिटिवली युग्मन करते हैं पास के पिन का।

पुल-अप रेसिस्टर्स

यदि कोई इनपुट मौजूद नहीं है, तो एक ज्ञात राज्य में एक इनपुट पिन को चलाने के लिए पुल-अप प्रतिरोध अक्सर उपयोगी होते हैं। यह एक पुल-अप रेसिस्टर (+ 5 वी), या इनपुट पर एक पुल-डाउन रेसिस्टर (जमीन के लिए अवरोध) को जोड़कर किया जा सकता है। एक 10K रोकनेवाला पुल-अप या पुल-डाउन रोकनेवाला के लिए एक अच्छा मूल्य है।

इनपुट के रूप में निर्मित पिंस के साथ अंतर्निहित पुल-अप रिसिस्टर का उपयोग करना

Atmega चिप में निर्मित 20,000 पुल-अप प्रतिरोध हैं जिन्हें सॉफ्टवेयर से एक्सेस किया जा सकता है। इन अंतर्निहित पुल-अप प्रतिरोधों को सेट करके पहुँचा जाता हैpinMode()INPUT_PULLUP के रूप में। यह प्रभावी रूप से INPUT मोड के व्यवहार को प्रभावित करता है, जहां उच्च का अर्थ सेंसर बंद है और कम का अर्थ है कि सेंसर चालू है। इस पुल-अप का मूल्य उपयोग किए गए माइक्रोकंट्रोलर पर निर्भर करता है। अधिकांश एवीआर-आधारित बोर्डों पर, मूल्य 20k 50 और 50kΩ के बीच होने की गारंटी है। Arduino ड्यू पर, यह 50k 150 और 150k Due के बीच है। सटीक मान के लिए, अपने बोर्ड पर माइक्रोकंट्रोलर की डेटशीट से परामर्श करें।

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

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

Example

pinMode(3,INPUT) ; // set pin to input without using built in pull up resistor
pinMode(5,INPUT_PULLUP) ; // set pin to input using built in pull up resistor

पिन को OUTPUT के रूप में कॉन्फ़िगर किया गया

पिनमोड () के साथ OUTPUT के रूप में कॉन्फ़िगर किए गए पिन को कम-प्रतिबाधा की स्थिति में कहा जाता है। इसका मतलब है कि वे अन्य सर्किटों को पर्याप्त मात्रा में वर्तमान प्रदान कर सकते हैं। एटमेगा पिन अन्य उपकरणों / सर्किटों के लिए वर्तमान के 40 mA (milliamps) तक (सकारात्मक वर्तमान प्रदान) या सिंक (नकारात्मक वर्तमान प्रदान) प्रदान कर सकते हैं। यह एक एलईडी को उज्ज्वल रूप से चमकने के लिए पर्याप्त है (श्रृंखला अवरोधक को मत भूलना), या कई सेंसर चलाएं लेकिन रिले, सोलनॉइड या मोटर्स को चलाने के लिए पर्याप्त वर्तमान नहीं।

आउटपुट पिन से उच्च वर्तमान उपकरणों को चलाने का प्रयास, पिन में आउटपुट ट्रांजिस्टर को नुकसान पहुंचा सकता है या नष्ट कर सकता है, या पूरे एटमेगा चिप को नुकसान पहुंचा सकता है। अक्सर, इसका परिणाम माइक्रोकंट्रोलर में "मृत" पिन में होता है लेकिन शेष चिप्स अभी भी पर्याप्त रूप से कार्य करते हैं। इस कारण से, OUTPUT पिन को 470Ω या 1k प्रतिरोधों के माध्यम से अन्य उपकरणों से कनेक्ट करना एक अच्छा विचार है, जब तक कि किसी विशेष एप्लिकेशन के लिए पिन से अधिकतम वर्तमान खींचना आवश्यक न हो।

pinMode () फ़ंक्शन

पिनमोड () फ़ंक्शन का उपयोग किसी विशिष्ट पिन को इनपुट या आउटपुट के रूप में व्यवहार करने के लिए किया जाता है। INPUT_PULLUP मोड के साथ आंतरिक पुल-अप प्रतिरोधों को सक्षम करना संभव है। इसके अतिरिक्त, INPUT मोड आंतरिक पुल-अप को स्पष्ट रूप से अक्षम करता है।

pinMode () फ़ंक्शन सिंटैक्स

Void setup () {
   pinMode (pin , mode);
}

  • pin - पिन की संख्या जिसका मोड आप सेट करना चाहते हैं

  • mode - INPUT, OUTPUT, या INPUT_PULLUP।

Example

int button = 5 ; // button connected to pin 5
int LED = 6; // LED connected to pin 6

void setup () {
   pinMode(button , INPUT_PULLUP); 
   // set the digital pin as input with pull-up resistor
   pinMode(button , OUTPUT); // set the digital pin as output
}

void setup () {
   If (digitalRead(button ) == LOW) // if button pressed {
      digitalWrite(LED,HIGH); // turn on led
      delay(500); // delay for 500 ms
      digitalWrite(LED,LOW); // turn off led
      delay(500); // delay for 500 ms
   }
}

digitalWrite () फ़ंक्शन

digitalWrite()फ़ंक्शन का उपयोग डिजिटल पिन के लिए एक उच्च या कम मान लिखने के लिए किया जाता है। यदि पिन को पिनमोड () के साथ एक OUTPUT के रूप में कॉन्फ़िगर किया गया है , तो इसके वोल्टेज को इसी मान पर सेट किया जाएगा: उच्च के लिए 5V (या 3.3V बोर्डों पर 3.3V), LOW के लिए 0V (ग्राउंड)। यदि पिन INPUT के रूप में कॉन्फ़िगर किया गया है, तो digitalWrite () इनपुट पिन पर आंतरिक पुलअप को सक्षम (उच्च) या अक्षम (LOW) करेगा। आंतरिक पुल-अप रोकनेवाला को सक्षम करने के लिए INMUT_PULLUP को पिनमोड () सेट करने की अनुशंसा की जाती है ।

यदि आप पिनमोड () को OUTPUT पर सेट नहीं करते हैं, और डिजिटलवर्ट (हाई) कॉल करते समय एक एलईडी को पिन से कनेक्ट करते हैं, तो एलईडी मंद दिखाई दे सकती है। पिनमोड () को स्पष्ट रूप से सेट किए बिना, डिजिटलवर्ट () ने आंतरिक पुल-अप रोकनेवाला सक्षम किया होगा, जो एक बड़े वर्तमान-सीमित अवरोधक की तरह काम करता है।

digitalWrite () फ़ंक्शन सिंटैक्स

Void loop() {
   digitalWrite (pin ,value);
}

  • pin - पिन की संख्या जिसका मोड आप सेट करना चाहते हैं

  • value - उच्च या कम।

Example

int LED = 6; // LED connected to pin 6

void setup () {
   pinMode(LED, OUTPUT); // set the digital pin as output
}

void setup () { 
   digitalWrite(LED,HIGH); // turn on led
   delay(500); // delay for 500 ms
   digitalWrite(LED,LOW); // turn off led
   delay(500); // delay for 500 ms
}

analogRead () फ़ंक्शन

Arduino यह पता लगाने में सक्षम है कि क्या उसके पिंस में से किसी एक पर वोल्टेज लागू होता है और digitalRead () फ़ंक्शन के माध्यम से रिपोर्ट करता है। ऑन / ऑफ सेंसर (जो किसी ऑब्जेक्ट की उपस्थिति का पता लगाता है) और एनालॉग सेंसर के बीच अंतर होता है, जिसका मूल्य लगातार बदलता रहता है। इस प्रकार के सेंसर को पढ़ने के लिए, हमें एक अलग प्रकार के पिन की आवश्यकता होती है।

Arduino बोर्ड के निचले-दाएं भाग में, आपको "एनालॉग इन" चिह्नित छह पिन दिखाई देंगे। ये विशेष पिन न केवल बताते हैं कि क्या उन पर लागू वोल्टेज है, बल्कि इसका मूल्य भी है। का उपयोग करकेanalogRead() फ़ंक्शन, हम किसी एक पिन पर लगाए गए वोल्टेज को पढ़ सकते हैं।

यह फ़ंक्शन 0 और 1023 के बीच एक संख्या देता है, जो 0 और 5 वोल्ट के बीच वोल्टेज का प्रतिनिधित्व करता है। उदाहरण के लिए, यदि पिन नंबर 0 पर लागू 2.5 वी का वोल्टेज है, तो एनालॉगरेड (0) रिटर्न 512 है।

analogRead () फ़ंक्शन सिंटैक्स

analogRead(pin);

  • pin - एनालॉग इनपुट पिन की संख्या को पढ़ने के लिए (0 से 5 सबसे बोर्डों पर, 0 से 7 मिनी और नैनो पर, 0 से 15 मेगा पर)

Example

int analogPin = 3;//potentiometer wiper (middle terminal) 
   // connected to analog pin 3 
int val = 0; // variable to store the value read

void setup() {
   Serial.begin(9600); // setup serial
} 

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}

इस अध्याय में, हम कुछ उन्नत इनपुट और आउटपुट फ़ंक्शंस सीखेंगे।

analogReference () फ़ंक्शन

एनालॉग इनपुट के लिए उपयोग किए जाने वाले संदर्भ वोल्टेज को कॉन्फ़िगर करता है (यानी इनपुट रेंज के शीर्ष के रूप में उपयोग किया जाने वाला मूल्य)। विकल्प हैं -

  • DEFAULT - 5 वोल्ट (5V Arduino बोर्ड पर) या 3.3 वोल्ट (3.3V Arduino बोर्ड पर) का डिफ़ॉल्ट एनालॉग संदर्भ

  • INTERNAL - एक अंतर्निहित संदर्भ, ATmega168 या ATmega328 पर 1.1 वोल्ट के बराबर और ATmega8 पर 2.56 वोल्ट (Arduino मेगा पर उपलब्ध नहीं)

  • INTERNAL1V1 - एक अंतर्निहित 1.1V संदर्भ (केवल Arduino मेगा)

  • INTERNAL2V56 - एक अंतर्निहित 2.56V संदर्भ (केवल Arduino मेगा)

  • EXTERNAL - अरेफ पिन (केवल 0 से 5 वी) पर लागू वोल्टेज को संदर्भ के रूप में उपयोग किया जाता है

analogReference () फ़ंक्शन सिंटैक्स

analogReference (type);

type - किसी भी प्रकार का अनुसरण कर सकते हैं (DEFAULT, INTERNAL, INTERNAL1V1, INTERNAL2V56, EXBNN)

अरे वी पिन पर बाहरी संदर्भ वोल्टेज के लिए 0 वी से कम या 5 वी से अधिक का उपयोग न करें। यदि आप अरेफ़ पिन पर किसी बाहरी संदर्भ का उपयोग कर रहे हैं, तो आपको कॉल करने से पहले बाहरी संदर्भ को एनालॉग संदर्भ में सेट करना होगाanalogRead()समारोह। अन्यथा, आप सक्रिय संदर्भ वोल्टेज (आंतरिक रूप से उत्पन्न) और एरीएफ पिन को कम कर देंगे, संभवतः आपके Arinoino बोर्ड पर माइक्रोकंट्रोलर को नुकसान पहुंचाएगा।

वैकल्पिक रूप से, आप बाहरी संदर्भ वोल्टेज को 5K रोकनेवाला के माध्यम से AreF पिन से जोड़ सकते हैं, जिससे आप बाहरी और आंतरिक संदर्भ वोल्टेज के बीच स्विच कर सकते हैं।

ध्यान दें कि अवरोधक उस वोल्टेज को बदल देगा जिसका उपयोग संदर्भ के रूप में किया जाता है क्योंकि अरेफ़ पिन पर एक आंतरिक 32K रोकनेवाला होता है। दो वोल्टेज विभक्त के रूप में कार्य करते हैं। उदाहरण के लिए, प्रतिरोधक के माध्यम से लागू किए गए 2.5 वी में एरीएफ पिन पर 2.5 * 32 / (32 + 5) = ~ 2.2V का उत्पादन होगा।

Example

int analogPin = 3;// potentiometer wiper (middle terminal) connected to analog pin 3 
int val = 0; // variable to store the read value

void setup() {
   Serial.begin(9600); // setup serial
   analogReference(EXTERNAL); // the voltage applied to the AREF pin (0 to 5V only) 
      // is used as the reference.
}

void loop() {
   val = analogRead(analogPin); // read the input pin
   Serial.println(val); // debug value
}

सभी डेटा को कंप्यूटर में वर्णों के रूप में दर्ज किया जाता है, जिसमें अक्षर, अंक और विभिन्न विशेष प्रतीक शामिल होते हैं। इस अनुभाग में, हम व्यक्तिगत पात्रों की जांच और हेरफेर के लिए C ++ की क्षमताओं पर चर्चा करते हैं।

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

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

निम्न तालिका वर्ण-हैंडलिंग लाइब्रेरी के कार्यों को सारांशित करती है। चरित्र-हैंडलिंग लाइब्रेरी से कार्यों का उपयोग करते समय, शामिल करें<cctype> हैडर।

क्र.सं. प्रोटोटाइप और विवरण
1

int isdigit( int c )

1 रिटर्न अगर c एक अंक है और 0 अन्यथा।
2

int isalpha( int c )

1 रिटर्न अगर c एक अक्षर है और 0 अन्यथा।
3

int isalnum( int c )

1 रिटर्न अगर c एक अंक या एक पत्र है और 0 अन्यथा।
4

int isxdigit( int c )

1 रिटर्न अगर c एक हेक्साडेसिमल अंक चरित्र है और 0 अन्यथा।

(बाइनरी, ऑक्टल, दशमलव और हेक्साडेसिमल संख्याओं की विस्तृत व्याख्या के लिए परिशिष्ट डी, संख्या प्रणाली देखें।)
5

int islower( int c )

1 रिटर्न अगर c एक लोअरकेस अक्षर है और 0 अन्यथा।
6

int isupper( int c )

1 रिटर्न अगर c एक अपरकेस अक्षर है; 0 अन्यथा।
7

int isspace( int c )

1 रिटर्न अगर c एक सफ़ेद-स्थान वर्ण है - newline ('\ n'), स्थान

(''), फ़ॉर्म फ़ीड ('\ f'), गाड़ी वापसी ('\ r'), क्षैतिज टैब ('\ t'), या ऊर्ध्वाधर टैब ('\ v') - और 0 अन्यथा।
8

int iscntrl( int c )

रिटर्न 1 यदि c एक नियंत्रण वर्ण है, जैसे कि newline ('\ n'), फ़ॉर्म फ़ीड ('\ f'), गाड़ी वापसी ('\ r'), क्षैतिज टैब ('\ t'), ऊर्ध्वाधर टैब (' \ v '), चेतावनी (' 'a'), या बैकस्पेस ('\ b') - और 0 अन्यथा।
9

int ispunct( int c )

1 रिटर्न अगर c एक अंतरिक्ष, एक अंक, या एक पत्र और 0 अन्यथा के अलावा एक मुद्रण चरित्र है।
10

int isprint( int c )

1 रिटर्न अगर c एक मुद्रण वर्ण है जिसमें अंतरिक्ष ('') और 0 शामिल हैं।
1 1

int isgraph( int c )

1 रिटर्न अगर c एक मुद्रण वर्ण है जो अंतरिक्ष ('') और 0 के अलावा है।

उदाहरण

निम्न उदाहरण कार्यों के उपयोग को दर्शाता है isdigit, isalpha, isalnum तथा isxdigit। समारोहisdigitनिर्धारित करता है कि क्या इसका तर्क एक अंक (0–9) है। कार्यक्रमisalphaयह निर्धारित करता है कि इसका तर्क एक अपरकेस अक्षर (AZ) या निचला अक्षर (a-z) है या नहीं। कार्यक्रमisalnumनिर्धारित करता है कि इसका तर्क एक अपरकेस, लोअरकेस अक्षर या एक अंक है। समारोहisxdigit निर्धारित करता है कि इसका तर्क एक हेक्साडेसिमल अंक (ए-एफ, ए-एफ, 0–9) है।

उदाहरण 1

void setup () {
   Serial.begin (9600);
   Serial.print ("According to isdigit:\r");
   Serial.print (isdigit( '8' ) ? "8 is a": "8 is not a");
   Serial.print (" digit\r" );
   Serial.print (isdigit( '8' ) ?"# is a": "# is not a") ;
   Serial.print (" digit\r");
   Serial.print ("\rAccording to isalpha:\r" );
   Serial.print (isalpha('A' ) ?"A is a": "A is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A' ) ?"b is a": "b is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha('A') ?"& is a": "& is not a");
   Serial.print (" letter\r");
   Serial.print (isalpha( 'A' ) ?"4 is a":"4 is not a");
   Serial.print (" letter\r");
   Serial.print ("\rAccording to isalnum:\r");
   Serial.print (isalnum( 'A' ) ?"A is a" : "A is not a" );

   Serial.print (" digit or a letter\r" );
   Serial.print (isalnum( '8' ) ?"8 is a" : "8 is not a" ) ;
   Serial.print (" digit or a letter\r");
   Serial.print (isalnum( '#' ) ?"# is a" : "# is not a" );
   Serial.print (" digit or a letter\r");
   Serial.print ("\rAccording to isxdigit:\r");
   Serial.print (isxdigit( 'F' ) ?"F is a" : "F is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'J' ) ?"J is a" : "J is not a" ) ;
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '7' ) ?"7 is a" : "7 is not a" ) ;

   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( '$' ) ? "$ is a" : "$ is not a" );
   Serial.print (" hexadecimal digit\r" );
   Serial.print (isxdigit( 'f' ) ? “f is a" : "f is not a");
   
}

void loop () {

}

परिणाम

According to isdigit:
8 is a digit
# is not a digit
According to isalpha:
A is a letter
b is a letter
& is not a letter
4 is not a letter
According to isalnum:
A is a digit or a letter

8 is a digit or a letter
# is not a digit or a letter
According to isxdigit:
F is a hexadecimal digit
J is not a hexadecimal digit
7 is a hexadecimal digit

$ is not a hexadecimal digit
f is a hexadecimal digit

हम सशर्त ऑपरेटर का उपयोग करते हैं (?:)प्रत्येक फ़ंक्शन के साथ यह निर्धारित करने के लिए कि क्या स्ट्रिंग "एक" है या स्ट्रिंग "नहीं है" को प्रत्येक वर्ण के लिए आउटपुट में मुद्रित किया जाना चाहिए। उदाहरण के लिए, रेखाa इंगित करता है कि यदि '8' एक अंक है - यानी, यदि isdigitएक सही (नॉनज़रो) मान लौटाता है - स्ट्रिंग "8 एक" मुद्रित है। यदि '8' अंक नहीं है (यानी, यदिisdigit रिटर्न 0), स्ट्रिंग "8 नहीं है" मुद्रित है।

उदाहरण 2

निम्न उदाहरण कार्यों के उपयोग को दर्शाता है islower तथा isupper। कार्यक्रमislowerनिर्धारित करता है कि क्या इसका तर्क एक लोअरकेस लेटर (a-z) है। समारोहisupper निर्धारित करता है कि क्या इसका तर्क एक अपरकेस अक्षर (A-Z) है।

int thisChar = 0xA0;

void setup () {
   Serial.begin (9600);
   Serial.print ("According to islower:\r") ;
   Serial.print (islower( 'p' ) ? "p is a" : "p is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( 'P') ? "P is a" : "P is not a") ;
   Serial.print ("lowercase letter\r");
   Serial.print (islower( '5' ) ? "5 is a" : "5 is not a" );
   Serial.print ( " lowercase letter\r" );
   Serial.print ( islower( '!' )? "! is a" : "! is not a") ;
   Serial.print ("lowercase letter\r");

   Serial.print ("\rAccording to isupper:\r") ;
   Serial.print (isupper ( 'D' ) ? "D is a" : "D is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( isupper ( 'd' )? "d is a" : "d is not an") ;
   Serial.print ( " uppercase letter\r" );
   Serial.print (isupper ( '8' ) ? "8 is a" : "8 is not an" );
   Serial.print ( " uppercase letter\r" );
   Serial.print ( islower( '$' )? "$ is a" : "$ is not an") ;
   Serial.print ("uppercase letter\r ");
}

void setup () {

}

परिणाम

According to islower:
p is a lowercase letter
P is not a lowercase letter
5 is not a lowercase letter
! is not a lowercase letter

According to isupper:
D is an uppercase letter
d is not an uppercase letter
8 is not an uppercase letter
$ is not an uppercase letter

उदाहरण 3

निम्न उदाहरण कार्यों के उपयोग को दर्शाता है isspace, iscntrl, ispunct, isprint तथा isgraph।

  • कार्यक्रम isspace यह निर्धारित करता है कि इसका तर्क श्वेत-अन्तरिक्ष वर्ण है, जैसे कि स्पेस (''), फॉर्म फीड ('\ f'), न्यूलाइन ('\ n'), गाड़ी वापसी ('\ r'), क्षैतिज टैब ('\') t ') या वर्टिकल टैब (' \ v ')।

  • कार्यक्रम iscntrl यह निर्धारित करता है कि इसका तर्क क्षैतिज टैब ('\ t'), वर्टिकल टैब ('\ v'), फ़ॉर्म फ़ीड ('\ f'), अलर्ट ('\' '), बैकस्पेस (' \ b) जैसे नियंत्रण वर्ण है या नहीं '), गाड़ी वापसी (' \ r ') या नई रेखा (' \ n ')।

  • कार्यक्रम ispunct यह निर्धारित करता है कि इसका तर्क $, #, (, (,), [,], {,},},:, या% जैसे किसी स्थान, अंक या अक्षर के अलावा एक मुद्रण वर्ण है या नहीं।

  • कार्यक्रम isprint निर्धारित करता है कि क्या इसका तर्क एक चरित्र है जिसे स्क्रीन पर प्रदर्शित किया जा सकता है (अंतरिक्ष वर्ण सहित)।

  • कार्यक्रम isgraph इस्प्रिंट के समान वर्णों के लिए परीक्षण, लेकिन अंतरिक्ष वर्ण शामिल नहीं है।

void setup () {
   Serial.begin (9600);
   Serial.print ( " According to isspace:\rNewline ") ;
   Serial.print (isspace( '\n' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\rHorizontal tab") ;
   Serial.print (isspace( '\t' )? " is a" : " is not a" );
   Serial.print ( " whitespace character\n") ;
   Serial.print (isspace('%')? " % is a" : " % is not a" );
   
   Serial.print ( " \rAccording to iscntrl:\rNewline") ;
   Serial.print ( iscntrl( '\n' )?"is a" : " is not a" ) ;
   Serial.print (" control character\r");
   Serial.print (iscntrl( '$' ) ? " $ is a" : " $ is not a" );
   Serial.print (" control character\r");
   Serial.print ("\rAccording to ispunct:\r");
   Serial.print (ispunct(';' ) ?"; is a" : "; is not a" ) ;
   Serial.print (" punctuation character\r");
   Serial.print (ispunct('Y' ) ?"Y is a" : "Y is not a" ) ;
   Serial.print ("punctuation character\r");
   Serial.print (ispunct('#' ) ?"# is a" : "# is not a" ) ;
   Serial.print ("punctuation character\r");

   Serial.print ( "\r According to isprint:\r");
   Serial.print (isprint('$' ) ?"$ is a" : "$ is not a" );
   Serial.print (" printing character\rAlert ");
   Serial.print (isprint('\a' ) ?" is a" : " is not a" );
   Serial.print (" printing character\rSpace ");
   Serial.print (isprint(' ' ) ?" is a" : " is not a" );
   Serial.print (" printing character\r");
   
   Serial.print ("\r According to isgraph:\r");
   Serial.print (isgraph ('Q' ) ?"Q is a" : "Q is not a" );
   Serial.print ("printing character other than a space\rSpace ");
   Serial.print (isgraph (' ') ?" is a" : " is not a" );
   Serial.print ("printing character other than a space ");
}

void loop () {

}

परिणाम

According to isspace:
Newline is a whitespace character
Horizontal tab is a whitespace character
% is not a whitespace character
According to iscntrl:
Newline is a control character
$ is not a control character
According to ispunct:
; is a punctuation character
Y is not a punctuation character
# is a punctuation character
According to isprint:
$ is a printing character
Alert is not a printing character
Space is a printing character
According to isgraph:
Q is a printing character other than a space
Space is not a printing character other than a space

Arduino Math लाइब्रेरी (math.h) में फ्लोटिंग-पॉइंट संख्याओं में हेरफेर करने के लिए कई उपयोगी गणितीय कार्य शामिल हैं।

लाइब्रेरी मैक्रोज़

शीर्षलेख गणित में परिभाषित मैक्रो निम्नलिखित हैं -

मैक्रो मूल्य विवरण
M_E 2.7182818284590452354 निरंतर ई।
M_LOG2E

1.4426950408889634074

/ * log_2 ई * /

 आधार 2 के लिए ई का लघुगणक
M_1_PI

.31830988618379067154

/ * 1 / पीआई * /

 लगातार 1 / पी
M_2_PI

.63661977236758134308

/ * 2 / पीआई * /

 लगातार 2 / पी
M_2_SQRTPI

1.12837916709551257390

/ * 2 / sqrt (पीआई) * /

 लगातार 2 / sqrt (pi)
M_LN10

2.30258509299404568402

/ * log_e 10 * /

 10 का प्राकृतिक लघुगणक
M_LN2

.69314718055994530942

/ * log_e 2 * /

 2 का प्राकृतिक लघुगणक
M_LOG10E

.43429448190325182765

/ * log_10 e * /

 बेस 10 के ई का लघुगणक
M_PI

3.14159265358979323846

/ * पीआई * /

 निरंतर पी
M_PI_2

3.3V1.57079632679489661923

/ * पीआई / २ * /

 निरंतर पी / 2
M_PI_4

.78539816339744830962

/ * पीआई / ४ * /

 निरंतर पी / 4
M_SQRT1_2

.70710678118654752440

/ * 1 / sqrt (2) * /

 लगातार 1 / sqrt (2)
M_SQRT2

1.41421356237309504880

/ * sqrt (2) * /

 २ का वर्गमूल
acosf - एसीओस () फ़ंक्शन के लिए उपनाम
asinf - असिन () फ़ंक्शन के लिए उपनाम
atan2f - Atan2 () फ़ंक्शन के लिए उपनाम
cbrtf - मलबे के लिए उपनाम () फ़ंक्शन
ceilf - छत के लिए उपनाम () फ़ंक्शन
copysignf - नकल के लिए उपनाम () फ़ंक्शन
coshf - कोश के लिए उपनाम () फ़ंक्शन
expf - EXP () फ़ंक्शन के लिए उपनाम
fabsf - फेब्स के लिए उपनाम () फ़ंक्शन
fdimf - Fdim () फ़ंक्शन के लिए उपनाम
floorf - फर्श के लिए उपनाम () फ़ंक्शन
fmaxf - Fmax () फ़ंक्शन के लिए उपनाम
fminf - उन्मादी () समारोह के लिए उपनाम
fmodf - Fmod () फ़ंक्शन के लिए उपनाम
frexpf - फ्रीक्सपी () फ़ंक्शन के लिए उपनाम
hypotf - हाइप () फ़ंक्शन के लिए उपनाम
अनंत - निरंतरता
isfinitef - Isfinite () फ़ंक्शन के लिए उपनाम
isinff - Isinf () फ़ंक्शन के लिए उपनाम
isnanf - आइसन के लिए उपनाम () फ़ंक्शन
ldexpf - एलडीएक्सपी () फ़ंक्शन के लिए उपनाम
log10f - Log10 के लिए उपनाम () फ़ंक्शन
logf - लॉग () फ़ंक्शन के लिए उपनाम
lrintf - लैंट () फ़ंक्शन के लिए उपनाम
lroundf - चारों ओर आलिया () फंक्शन के लिए

पुस्तकालय के कार्य

शीर्षलेख में निम्नलिखित कार्य परिभाषित हैं math.h -

क्र.सं. पुस्तकालय समारोह और विवरण
1

double acos (double __x)

एको () फ़ंक्शन __x के आर्क कोसाइन के प्रमुख मूल्य की गणना करता है। लौटाया गया मूल्य सीमा [0, pi] रेडियन में है। एक डोमेन त्रुटि तर्कों के लिए होती है [-1, +1] सीमा में नहीं।
2

double asin (double __x)

असिन () फ़ंक्शन __x के चाप साइन के प्रमुख मूल्य की गणना करता है। लौटाया गया मान सीमा [-pi / 2, pi / 2] रेडियन में है। एक डोमेन त्रुटि तर्कों के लिए होती है [-1, +1] सीमा में नहीं।
3

double atan (double __x)

अतन () फ़ंक्शन __x के चाप स्पर्शरेखा के प्रमुख मूल्य की गणना करता है। लौटाया गया मान सीमा [-pi / 2, pi / 2] रेडियन में है।
4

double atan2 (double __y, double __x)

Atan2 () फ़ंक्शन __y / __x के चाप स्पर्शरेखा के मुख्य मूल्य की गणना करता है, वापसी मान के चतुर्थांश को निर्धारित करने के लिए दोनों तर्कों के संकेतों का उपयोग करता है। लौटाया गया मूल्य सीमा [-pi, + pi] रेडियन में है।
5

double cbrt (double __x)

Cbrt () फ़ंक्शन __x की घनमूल लौटाता है।
6

double ceil (double __x)

छत () फ़ंक्शन फ्लोटिंग-पॉइंट संख्या के रूप में व्यक्त किए गए __x के मुकाबले सबसे छोटा अभिन्न मान लौटाता है।
7

static double copysign (double __x, double __y)

नकल () फ़ंक्शन __x देता है लेकिन __y के संकेत के साथ। वे काम करते हैं भले ही __x या __y NaN या शून्य हो।
8

double cos(double __x)

कॉड () फ़ंक्शन रेडियन में मापा गया __x का कोसिन लौटाता है।
9

double cosh (double __x)

कोश () फ़ंक्शन __x का हाइपरबोलिक कोसिन लौटाता है।
10

double exp (double __x)

एक्सप () फ़ंक्शन __x का घातीय मान लौटाता है।
1 1

double fabs (double __x)

फेब्स () फ़ंक्शन फ्लोटिंग-पॉइंट नंबर __x के निरपेक्ष मान की गणना करता है।
12

double fdim (double __x, double __y)

Fdim () फ़ंक्शन अधिकतम देता है (__ x - __y, 0)। यदि __x या __y या दोनों NaN हैं, तो NaN लौटाया जाता है।
13

double floor (double __x)

फर्श () फ़ंक्शन फ्लोटिंग-पॉइंट नंबर के रूप में व्यक्त __x से कम या बराबर का सबसे बड़ा अभिन्न मान लौटाता है।
14

double fma (double __x, double __y, double __z)

Fma () फ़ंक्शन फ़्लोटिंग-पॉइंट गुणा-जोड़ करता है। यह ऑपरेशन (__x * __y) + __z है, लेकिन मध्यवर्ती परिणाम गंतव्य प्रकार के लिए गोल नहीं है। यह कभी-कभी गणना की शुद्धता में सुधार कर सकता है।
15

double fmax (double __x, double __y)

Fmax () फ़ंक्शन दो मानों __x और __y से अधिक लौटाता है। यदि एक तर्क NaN है, तो दूसरा तर्क वापस आ जाता है। यदि दोनों तर्क NaN हैं, तो NaN वापस कर दिया जाता है।
16

double fmin (double __x, double __y)

Fmin () फ़ंक्शन दो मान __x और __y का कम रिटर्न देता है। यदि एक तर्क NaN है, तो दूसरा तर्क वापस आ जाता है। यदि दोनों तर्क NaN हैं, तो NaN वापस कर दिया जाता है।
17

double fmod (double __x, double__y)

फ़ंक्शन fmod () __x / __y के फ़्लोटिंग-शेष शेष को लौटाता है।
18

double frexp (double __x, int * __pexp)

Frexp () फ़ंक्शन एक फ्लोटिंग-पॉइंट नंबर को एक सामान्यीकृत अंश में और एक अभिन्न शक्ति को तोड़ता है। यह __pexp द्वारा इंगित इंट ऑब्जेक्ट में पूर्णांक को संग्रहीत करता है। यदि __x एक सामान्य फ्लोट बिंदु संख्या है, तो frexp () फ़ंक्शन मान v लौटाता है, जैसे कि v का अंतराल [1/2, 1) या शून्य में होता है, और __x v के बराबर होता है v पावर 2 में उठाया गया 2 गुना। यदि __x शून्य है, तो परिणाम के दोनों भाग शून्य हैं। यदि __x एक परिमित संख्या नहीं है, तो frexp () __x है और __pexp द्वारा 0 स्टोर करता है।

Note - यह कार्यान्वयन एक्सपोनेंट को स्टोर करने के निर्देश के रूप में एक शून्य पॉइंटर को अनुमति देता है।
19

double hypot (double __x, double__y)

द हाइप () फ़ंक्शन sqrt (__ x * __ x + __y * __ y) देता है। यह दाएं त्रिभुज की कर्ण की लंबाई है जिसकी लंबाई __x और __y है, या मूल से बिंदु (__x, __y) की दूरी है। प्रत्यक्ष सूत्र के बजाय इस फ़ंक्शन का उपयोग करना बुद्धिमान है, क्योंकि त्रुटि बहुत छोटी है। छोटे __x और __y के साथ कोई अंडरफ़्लो नहीं। यदि परिणाम रेंज में है तो कोई अतिप्रवाह नहीं।
20

static int isfinite (double __x)

Isfinite () फ़ंक्शन एक गैर-अक्षीय मान लौटाता है यदि __x परिमित है: प्लस या माइनस इनफिनिटी नहीं, और नहीं NaN।
21

int isinf (double __x)

फ़ंक्शन isinf () 1 देता है यदि तर्क __x सकारात्मक अनंत है, -1 यदि __x नकारात्मक अनंत है, और 0 अन्यथा।

Note - जीसीसी 4.3 इस फ़ंक्शन को इनलाइन कोड के साथ बदल सकता है जो दोनों शिशुओं के लिए 1 मान लौटाता है (gcc बग # 35509)।
22

int isnan (double __x)

फ़ंक्शन isnan () 1 देता है यदि तर्क __x "नहीं-एक-संख्या" का प्रतिनिधित्व करता है ()NaN) वस्तु, अन्यथा ०।
23

double ldexp (double __x, int __exp )

Ldexp () फ़ंक्शन एक फ्लोटिंग-पॉइंट संख्या को 2. की एक इंटीग्रल पावर से गुणा करता है। यह __x 2 के मान को पावर __exp पर लौटाता है।
24

double log (double __x)

लॉग () फ़ंक्शन तर्क का प्राकृतिक लघुगणक लौटाता है __x।
25

double log10(double __x)

लॉग 10 () फ़ंक्शन 10 से बेस 10 तक तर्क का लॉगरिदम देता है।
26

long lrint (double __x)

Lrint () फंक्शन __x को निकटतम पूर्णांक तक ले जाता है, आधे मामलों को सम पूर्ण दिशा में गोल करता है। (वह 1.5 और 2.5 दोनों मान 2 के गोल हैं)। यह फ़ंक्शन रिंट () फ़ंक्शन के समान है, लेकिन यह रिटर्न वैल्यू के प्रकार में भिन्न है और इसमें एक अतिप्रवाह संभव है।

Returns

गोल लंबा पूर्णांक मान। यदि __x एक परिमित संख्या या अतिप्रवाह नहीं है, तो यह बोध LONG_MIN मान (0x80000000) लौटाता है।
27

long lround (double __x)

निकटतम (पूर्णांक) फंक्शन __x को निकटतम पूर्णांक तक ले जाता है, लेकिन आधे मामलों को शून्य से दूर करता है (निकटतम सम पूर्णांक के बजाय)। यह फ़ंक्शन राउंड () फ़ंक्शन के समान है, लेकिन यह रिटर्न वैल्यू के प्रकार में भिन्न है और इसमें एक अतिप्रवाह संभव है।

Returns

गोल लंबा पूर्णांक मान। यदि __x एक परिमित संख्या नहीं है या एक अतिप्रवाह था, तो यह बोध LONG_MIN मान (0x80000) लौटाता है।
28

double modf (double __x, double * __iptr )

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

Modf () फ़ंक्शन __x के हस्ताक्षरित आंशिक भाग को लौटाता है।

Note- यह कार्यान्वयन शून्य पॉइंटर द्वारा लेखन को रोक देता है। हालांकि, GCC 4.3 इस फ़ंक्शन को इनलाइन कोड से बदल सकता है जो भंडारण से बचने के लिए NULL पते का उपयोग करने की अनुमति नहीं देता है।
29

float modff (float __x, float * __iptr)

मॉडफ के लिए उपनाम ()।
30

double pow (double __x, double __y)

फ़ंक्शन पॉव () घातांक के लिए __x का मान लौटाता है।
31

double round (double __x)

राउंड () फ़ंक्शन राउंड __x निकटतम पूर्णांक तक जाता है, लेकिन राउंड आधे मामले शून्य से दूर होते हैं (निकटतम पूर्णांक के बजाय)। अतिप्रवाह असंभव है।

Returns

गोल मूल्य। यदि __x एक अभिन्न या अनंत है, तो __x ही वापस आ जाता है। अगर __x हैNaN, फिर NaN वापस आ गया है।
32

int signbit (double __x)

यदि __x का मान थोड़ा सा सेट किया गया है, तो साइनबिट () फ़ंक्शन एक नॉनज़ेरो मान लौटाता है। यह `__x <0.0 'के समान नहीं है, क्योंकि IEEE 754 फ़्लोटिंग पॉइंट शून्य पर हस्ताक्षर करने की अनुमति देता है। तुलना `-0.0 <0.0 'झूठी है, लेकिन` साइनबिट (-0.0)' एक गैर-मूल्य पर वापस आ जाएगी।
33

double sin (double __x)

पाप () फ़ंक्शन रेडियन में मापा गया __x का साइन लौटाता है।
34

double sinh (double __x)

Sinh () फ़ंक्शन __x की हाइपरबोलिक साइन देता है।
35

double sqrt (double __x)

Sqrt () फ़ंक्शन __x का गैर-नकारात्मक वर्ग रूट लौटाता है।
36

double square (double __x)

फ़ंक्शन स्क्वायर () __x * __x देता है।

Note - यह फ़ंक्शन सी मानक परिभाषा से संबंधित नहीं है।
37

double tan (double __x)

टैन () फ़ंक्शन रेडियन में मापा गया __x का स्पर्शरेखा लौटाता है।
38

double tanh ( double __x)

तन () फ़ंक्शन __x की हाइपरबोलिक स्पर्शरेखा लौटाता है।
39

double trunc (double __x)

पूर्णांक में पूर्णांक बड़ा होने के लिए ट्रंक () फ़ंक्शन राउंड __x है।

उदाहरण

निम्नलिखित उदाहरण से पता चलता है कि कैसे सबसे आम math.h पुस्तकालय कार्यों का उपयोग किया जाता है -

double double__x = 45.45 ;
double double__y = 30.20 ;

void setup() {
   Serial.begin(9600);
   Serial.print("cos num = ");
   Serial.println (cos (double__x) ); // returns cosine of x
   Serial.print("absolute value of num = ");
   Serial.println (fabs (double__x) ); // absolute value of a float
   Serial.print("floating point modulo = ");
   Serial.println (fmod (double__x, double__y)); // floating point modulo
   Serial.print("sine of num = ");
   Serial.println (sin (double__x) ) ;// returns sine of x
   Serial.print("square root of num : ");
   Serial.println ( sqrt (double__x) );// returns square root of x
   Serial.print("tangent of num : ");
   Serial.println ( tan (double__x) ); // returns tangent of x
   Serial.print("exponential value of num : ");
   Serial.println ( exp (double__x) ); // function returns the exponential value of x.
   Serial.print("cos num : ");

   Serial.println (atan (double__x) ); // arc tangent of x
   Serial.print("tangent of num : ");
   Serial.println (atan2 (double__y, double__x) );// arc tangent of y/x
   Serial.print("arc tangent of num : ");
   Serial.println (log (double__x) ) ; // natural logarithm of x
   Serial.print("cos num : ");
   Serial.println ( log10 (double__x)); // logarithm of x to base 10.
   Serial.print("logarithm of num to base 10 : ");
   Serial.println (pow (double__x, double__y) );// x to power of y
   Serial.print("power of num : ");
   Serial.println (square (double__x)); // square of x
}

void loop() {

}

परिणाम

cos num = 0.10
absolute value of num = 45.45
floating point modulo =15.25
sine of num = 0.99
square root of num : 6.74
tangent of num : 9.67
exponential value of num : ovf
cos num : 1.55
tangent of num : 0.59
arc tangent of num : 3.82
cos num : 1.66
logarithm of num to base 10 : inf
power of num : 2065.70

आपको ट्रिगोनोमेट्री का उपयोग व्यावहारिक रूप से करने की आवश्यकता है जैसे चलती वस्तु या कोणीय गति के लिए दूरी की गणना करना। Arduino पारंपरिक त्रिकोणमितीय कार्य (पाप, कॉस, टैन, असिन, एसीओएस, एटान) प्रदान करता है जिन्हें उनके प्रोटोटाइप को लिखकर संक्षेप में प्रस्तुत किया जा सकता है। Math.h में त्रिकोणमिति फ़ंक्शन का प्रोटोटाइप शामिल है।

त्रिकोणमितीय सटीक सिंटैक्स

double sin(double x); //returns sine of x radians
double cos(double y); //returns cosine of y radians
double tan(double x); //returns the tangent of x radians
double acos(double x); //returns A, the angle corresponding to cos (A) = x
double asin(double x); //returns A, the angle corresponding to sin (A) = x
double atan(double x); //returns A, the angle corresponding to tan (A) = x

उदाहरण

double sine = sin(2); // approximately 0.90929737091
double cosine = cos(2); // approximately -0.41614685058
double tangent = tan(2); // approximately -2.18503975868

Arduino ड्यूक, Atmel SAM3X8E ARM Cortex-M3 CPU पर आधारित एक माइक्रोकंट्रोलर बोर्ड है। यह 32-बिट ARM कोर माइक्रोकंट्रोलर पर आधारित पहला Arduino बोर्ड है।

महत्वपूर्ण विशेषताएं -

  • इसमें 54 डिजिटल इनपुट / आउटपुट पिन हैं (जिनमें से 12 को PWM आउटपुट के रूप में इस्तेमाल किया जा सकता है)
  • 12 एनालॉग इनपुट
  • 4 UARTs (हार्डवेयर सीरियल पोर्ट)
  • 84 मेगाहर्ट्ज घड़ी, एक यूएसबी ओटीजी सक्षम कनेक्शन
  • 2 DAC (डिजिटल से एनालॉग), 2 TWI, एक पावर जैक, एक SPI हेडर, एक JTAG हेडर
  • रीसेट बटन और मिटा बटन

Arduino ड्यू बोर्ड के लक्षण

ऑपरेटिंग वोल्ट सीपीयू गति में / बाहर अनुरूप डिजिटल IO / PWM EEPROM [KB] SRAM [KB] फ्लैश [KB] यु एस बी UART
३.३ वोल्ट 84 मेगाहर्ट्ज 12/2 54/12 - 96 512 2 माइक्रो 4

संचार

  • 4 हार्डवेयर UARTs
  • 2 I2C
  • 1 कर सकते हैं इंटरफ़ेस (मोटर वाहन संचार प्रोटोकॉल)
  • 1 एसपीआई
  • 1 इंटरफ़ेस जेटीएजी (10 पिन)
  • 1 USB होस्ट (लियोनार्डो की तरह)
  • 1 प्रोग्रामिंग पोर्ट

अधिकांश Arduino बोर्डों के विपरीत, Arduino ड्यू बोर्ड 3.3V पर चलता है। अधिकतम वोल्टेज जिसे I / O पिंस सहन कर सकता है वह 3.3V है। किसी भी I / O पिन से 3.3V से अधिक वोल्टेज लागू करने से बोर्ड को नुकसान हो सकता है।

बोर्ड में माइक्रोकंट्रोलर का समर्थन करने के लिए आवश्यक सभी चीजें शामिल हैं। आप बस इसे माइक्रो-यूएसबी केबल के साथ कंप्यूटर से कनेक्ट कर सकते हैं या इसे शुरू करने के लिए एसी-टू-डीसी एडाप्टर या बैटरी के साथ पावर कर सकते हैं। देय सभी Arduino शील्ड्स के साथ संगत है जो 3.3V पर काम करते हैं।

अरुडिनो जीरो

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

महत्वपूर्ण विशेषताएं हैं -

  • जीरो एप्लीकेशन स्मार्ट आईओटी डिवाइसेज, वियरेबल टेक्नोलॉजी, हाई-टेक ऑटोमेशन से लेकर क्रेजी रोबोटिक्स तक फैला हुआ है।

  • बोर्ड Atmel के SAMD21 MCU द्वारा संचालित है, जिसमें 32-बिट ARM Cortex® M0 + कोर है।

  • इसकी सबसे महत्वपूर्ण विशेषताओं में से एक Atmel का एंबेडेड डीबगर (EDBG) है, जो अतिरिक्त हार्डवेयर की आवश्यकता के बिना एक पूर्ण डिबग इंटरफ़ेस प्रदान करता है, सॉफ्टवेयर डिबगिंग के लिए आसानी से उपयोग को बढ़ाता है।

  • EDBG एक वर्चुअल COM पोर्ट का भी समर्थन करता है जिसका उपयोग डिवाइस और बूटलोडर प्रोग्रामिंग के लिए किया जा सकता है।

अरुडिनो शून्य बोर्ड की विशेषताएं

ऑपरेटिंग वोल्ट सीपीयू गति में / बाहर अनुरूप डिजिटल IO / PWM EEPROM [KB] SRAM [KB] फ्लैश [KB] यु एस बी UART
३.३ वोल्ट 48 मेगाहर्ट्ज 6/1 14/10 - 32 256 2 माइक्रो 2

अधिकांश Arduino और Genuino बोर्डों के विपरीत, शून्य 3.3V पर चलता है। अधिकतम वोल्टेज जिसे I / O पिंस सहन कर सकता है वह 3.3V है। किसी भी I / O पिन से 3.3V से अधिक वोल्टेज लागू करने से बोर्ड को नुकसान हो सकता है।

बोर्ड में माइक्रोकंट्रोलर का समर्थन करने के लिए आवश्यक सभी चीजें शामिल हैं। आप बस माइक्रो-यूएसबी केबल के साथ इसे कंप्यूटर से कनेक्ट कर सकते हैं या इसे शुरू करने के लिए एसी-टू-डीसी एडाप्टर या बैटरी के साथ पावर कर सकते हैं। शून्य 3.3V पर काम करने वाले सभी ढालों के साथ संगत है।

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

PWM का मूल सिद्धांत

पल्स चौड़ाई मॉड्यूलेशन मूल रूप से, अलग-अलग उच्च और निम्न समय के साथ एक वर्ग तरंग है। एक बुनियादी पीडब्लूएम संकेत निम्नलिखित आकृति में दिखाया गया है।

PWM से जुड़े विभिन्न शब्द हैं -

  • On-Time - समय संकेत की अवधि अधिक है।

  • Off-Time - समय संकेत की अवधि कम है।

  • Period - इसे PWM सिग्नल के ऑन-टाइम और ऑफ-टाइम के योग के रूप में दर्शाया गया है।

  • Duty Cycle - यह समय सिग्नल के प्रतिशत के रूप में दर्शाया जाता है जो PWM सिग्नल की अवधि के दौरान रहता है।

अवधि

जैसा कि चित्र में दिखाया गया है, T ऑन -टाइम को दर्शाता है और T ऑफ सिग्नल का ऑफ-टाइम दर्शाता है। अवधि दोनों पर और बंद समय का योग है और निम्न समीकरण में दिखाया गया है -

साइकिल शुल्क

कर्तव्य चक्र की गणना समय की अवधि के समय के रूप में की जाती है। ऊपर दी गई अवधि का उपयोग करके, कर्तव्य चक्र की गणना इस प्रकार की जाती है -

analogWrite () फ़ंक्शन

analogWrite()फ़ंक्शन एक पिन करने के लिए एक एनालॉग मूल्य (PWM लहर) लिखता है। यह अलग-अलग चमक पर एक एलईडी प्रकाश करने या विभिन्न गति से मोटर चलाने के लिए इस्तेमाल किया जा सकता है। AnalogWrite () फ़ंक्शन की कॉल के बाद, पिन निर्दिष्ट कर्तव्य चक्र की एक स्थिर वर्ग तरंग उत्पन्न करेगा जब तक कि अगली कॉल analogWrite () या digitalRead () या digitalWrite () को एक ही पिन पर कॉल न कर दे। अधिकांश पिनों पर पीडब्लूएम सिग्नल की आवृत्ति लगभग 490 हर्ट्ज है। ऊनो और इसी तरह के बोर्डों पर, पिन 5 और 6 में लगभग 980 हर्ट्ज की आवृत्ति होती है। लियोनार्डो पर पिंस 3 और 11 भी 980 हर्ट्ज पर चलते हैं।

अधिकांश Arduino बोर्डों (ATmega168 या ATmega328 वाले) पर, यह फ़ंक्शन पिन 3, 5, 6, 9, 10 और 11 पर काम करता है। Arduino Mega पर, यह पिन 2 - 13 और 44 - 46 पर काम करता है। Old Ar Arinoino ATmega8 वाले बोर्ड ही सपोर्ट करते हैं analogWrite() पिन 9, 10 और 11 पर।

द Arduino ड्यू सपोर्ट करता है analogWrite()13 के माध्यम से 2 पिन पर, और DAC0 और DAC1 पिन करें। PWM पिन के विपरीत, DAC0 और DAC1 एनालॉग कन्वर्टर्स के लिए डिजिटल हैं, और सच्चे एनालॉग आउटपुट के रूप में कार्य करते हैं।

एनालॉगवर्ट () कॉल करने से पहले पिन को आउटपुट के रूप में सेट करने के लिए आपको पिनमोड () को कॉल करने की आवश्यकता नहीं है।

analogWrite () फ़ंक्शन सिंटैक्स

analogWrite ( pin , value ) ;

value - कर्तव्य चक्र: 0 (हमेशा बंद) और 255 (हमेशा) के बीच।

Example

int ledPin = 9; // LED connected to digital pin 9
int analogPin = 3; // potentiometer connected to analog pin 3
int val = 0; // variable to store the read value

void setup() {
   pinMode(ledPin, OUTPUT); // sets the pin as output
}

void loop() {
   val = analogRead(analogPin); // read the input pin
   analogWrite(ledPin, (val / 4)); // analogRead values go from 0 to 1023, 
      // analogWrite values from 0 to 255
}

यादृच्छिक संख्या उत्पन्न करने के लिए, आप Arduino यादृच्छिक संख्या कार्यों का उपयोग कर सकते हैं। हमारे दो कार्य हैं -

  • randomSeed(seed)
  • random()

randomSeed (बीज)

समारोह randomSeed (बीज) Arduino के छद्म आयामी संख्या जनरेटर को रीसेट करता है। यद्यपि संख्याओं का वितरण यादृच्छिक रूप से () अनिवार्य रूप से यादृच्छिक है, अनुक्रम अनुमानित है। आपको जनरेटर को कुछ यादृच्छिक मूल्य पर रीसेट करना चाहिए। यदि आपके पास एक असंबद्ध एनालॉग पिन है, तो यह आसपास के वातावरण से यादृच्छिक शोर उठा सकता है। ये रेडियो तरंगें, ब्रह्मांडीय किरणें, सेल फोन से विद्युत चुम्बकीय हस्तक्षेप, फ्लोरोसेंट रोशनी और इतने पर हो सकते हैं।

उदाहरण

randomSeed(analogRead(5)); // randomize using noise from analog pin 5

यादृच्छिक ()

यादृच्छिक फ़ंक्शन छद्म यादृच्छिक संख्या उत्पन्न करता है। निम्नलिखित वाक्य रचना है।

random () कथन सिंटैक्स

long random(max) // it generate random numbers from 0 to max
long random(min, max) // it generate random numbers from min to max

उदाहरण

long randNumber;

void setup() {
   Serial.begin(9600);
   // if analog input pin 0 is unconnected, random analog
   // noise will cause the call to randomSeed() to generate
   // different seed numbers each time the sketch runs.
   // randomSeed() will then shuffle the random function.
   randomSeed(analogRead(0));
}

void loop() {
   // print a random number from 0 to 299
   Serial.print("random1=");
   randNumber = random(300);
   Serial.println(randNumber); // print a random number from 0to 299
   Serial.print("random2=");
   randNumber = random(10, 20);// print a random number from 10 to 19
   Serial.println (randNumber);
   delay(50);
}

आइए अब हम कुछ बुनियादी अवधारणाओं जैसे बिट्स और बाइट्स पर अपने ज्ञान को ताज़ा करें।

बिट्स

एक बिट सिर्फ एक द्विआधारी अंक है।

  • बाइनरी सिस्टम दो अंकों, 0 और 1 का उपयोग करता है।

  • दशमलव संख्या प्रणाली के समान, जिसमें संख्या के अंकों का समान मूल्य नहीं होता है, बिट का 'महत्व' द्विआधारी संख्या में इसकी स्थिति पर निर्भर करता है। उदाहरण के लिए, दशमलव संख्या 666 में अंक समान होते हैं, लेकिन उनके अलग-अलग मूल्य होते हैं।

बाइट्स

एक बाइट में आठ बिट्स होते हैं।

  • यदि बिट एक अंक है, तो यह तर्कसंगत है कि बाइट्स संख्याओं का प्रतिनिधित्व करते हैं।

  • उन पर सभी गणितीय कार्य किए जा सकते हैं।

  • एक बाइट में अंकों का भी उतना महत्व नहीं है।

  • बाईं ओर के बिट में मोस्ट सिग्निफिकेंट बिट (MSB) नामक सबसे बड़ा मूल्य होता है।

  • सबसे दाहिने बिट का कम से कम मूल्य है और इसलिए, लिस्ट सिग्नेचर बिट (एलएसबी) कहा जाता है।

  • चूंकि आठ शून्य और एक बाइट के लोगों को 256 अलग-अलग तरीकों से जोड़ा जा सकता है, इसलिए सबसे बड़ी दशमलव संख्या जिसे एक बाइट द्वारा दर्शाया जा सकता है 255 (एक संयोजन एक शून्य का प्रतिनिधित्व करता है)।

रुकावट Arduino के वर्तमान काम को रोकते हैं जैसे कि कुछ और काम किया जा सकता है।

मान लीजिए आप घर पर बैठे हैं, किसी के साथ बातचीत कर रहे हैं। अचानक टेलीफोन की घंटी बजी। आप चैट करना बंद कर देते हैं, और कॉलर से बात करने के लिए टेलीफोन उठाते हैं। जब आप अपना टेलीफ़ोनिक वार्तालाप समाप्त कर लेते हैं, तो आप टेलीफ़ोन बजने से पहले उस व्यक्ति के साथ चैटिंग पर वापस चले जाते हैं।

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

मुख्य कार्यक्रम चल रहा है और एक सर्किट में कुछ कार्य कर रहा है। हालांकि, जब एक अवरोधन होता है तो मुख्य कार्यक्रम रुक जाता है जबकि एक अन्य दिनचर्या की जाती है। जब यह रूटीन खत्म हो जाता है, तो प्रोसेसर फिर से मुख्य रूटीन में वापस चला जाता है।

महत्वपूर्ण विशेषताएं

इंटरप्ट के बारे में कुछ महत्वपूर्ण विशेषताएं इस प्रकार हैं -

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

  • अधिकांश Arduino डिजाइनों में दो डिजिटल इंटरप्ट होते हैं (जिन्हें "अवरोध 0" और "इंटरप्ट 1" कहा जाता है) क्रमशः डिजिटल I / O पिन 2 और 3 के लिए हार्ड-वायर्ड।

  • Arduino Mega में 21, 20, 19 और 18 पर पिन्स पर "इंटरप्ट 5" के माध्यम से अतिरिक्त इंटरप्ट ("इंटरप्ट 2") सहित छह हार्डवेयर इंटरप्ट हैं।

  • आप एक विशेष फ़ंक्शन को "इंटरप्ट सर्विस सर्विस" (आमतौर पर आईएसआर के रूप में जाना जाता है) का उपयोग करके एक रूटीन को परिभाषित कर सकते हैं।

  • आप दिनचर्या को परिभाषित कर सकते हैं और बढ़ती बढ़त, गिरने वाले किनारे या दोनों पर स्थितियां निर्दिष्ट कर सकते हैं। इन विशिष्ट स्थितियों में, व्यवधान को सेवित किया जाएगा।

  • यह संभव है कि फ़ंक्शन स्वचालित रूप से निष्पादित हो, हर बार एक घटना एक इनपुट पिन पर होती है।

व्यवधान के प्रकार

दो प्रकार के व्यवधान हैं -

  • Hardware Interrupts - वे एक बाहरी घटना की प्रतिक्रिया में होते हैं, जैसे कि एक बाहरी अवरोधक पिन उच्च या निम्न जा रहा है।

  • Software Interrupts- वे सॉफ्टवेयर में भेजे गए एक निर्देश के जवाब में होते हैं। "Arduino भाषा" का एकमात्र प्रकार का अवरोधक संलग्नक () फ़ंक्शन है।

Arduino में इंटरप्ट का उपयोग करना

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

आमतौर पर, वैश्विक चर का उपयोग आईएसआर और मुख्य कार्यक्रम के बीच डेटा पारित करने के लिए किया जाता है। यह सुनिश्चित करने के लिए कि ISR और मुख्य कार्यक्रम के बीच साझा किए गए चर सही ढंग से अपडेट किए गए हैं, उन्हें अस्थिर घोषित करें।

अटैचमेंट स्टेटमेंट सिंटैक्स

attachInterrupt(digitalPinToInterrupt(pin),ISR,mode);//recommended for arduino board
attachInterrupt(pin, ISR, mode) ; //recommended Arduino Due, Zero only
//argument pin: the pin number
//argument ISR: the ISR to call when the interrupt occurs; 
   //this function must take no parameters and return nothing. 
   //This function is sometimes referred to as an interrupt service routine.
//argument mode: defines when the interrupt should be triggered.

निम्नलिखित तीन स्थिरांक मान्य मानों के रूप में पूर्वनिर्धारित हैं -

  • LOW जब भी पिन कम हो, तो बाधा को ट्रिगर करें।

  • CHANGE जब भी पिन बदलता है, तो रुकावट को ट्रिगर करना।

  • FALLING जब भी पिन हाई से लो हो जाए।

Example

int pin = 2; //define interrupt pin to 2
volatile int state = LOW; // To make sure variables shared between an ISR
//the main program are updated correctly,declare them as volatile.

void setup() {
   pinMode(13, OUTPUT); //set pin 13 as output
   attachInterrupt(digitalPinToInterrupt(pin), blink, CHANGE);
   //interrupt at pin 2 blink ISR when pin to change the value
} 
void loop() { 
   digitalWrite(13, state); //pin 13 equal the state value
} 

void blink() { 
   //ISR function
   state = !state; //toggle the state when the interrupt occurs
}

इस डेटा विनिमय को प्राप्त करने के लिए सैकड़ों संचार प्रोटोकॉल परिभाषित किए गए हैं। प्रत्येक प्रोटोकॉल को दो श्रेणियों में से एक में वर्गीकृत किया जा सकता है: समानांतर या धारावाहिक।

समानांतर संचार

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

समानांतर संचार के लाभ और कमियां

समानांतर संचार निश्चित रूप से इसके फायदे हैं। यह धारावाहिक की तुलना में तेज़ है, सीधा और अपेक्षाकृत आसान है। हालाँकि, इसके लिए कई इनपुट / आउटपुट (I / O) पोर्ट और लाइनों की आवश्यकता होती है। यदि आपको कभी भी किसी प्रोजेक्ट को मूल Arduino Uno से मेगा में स्थानांतरित करना है, तो आप जानते हैं कि एक माइक्रोप्रोसेसर पर I / O लाइनें कीमती और कुछ हो सकती हैं। इसलिए, हम सीरियल संचार पसंद करते हैं, पिन रियल एस्टेट के लिए संभावित गति का त्याग करते हैं।

सीरियल कम्युनिकेशन मॉड्यूल

आज, अधिकांश Arduino बोर्ड मानक उपकरणों के रूप में धारावाहिक संचार के लिए कई अलग-अलग प्रणालियों के साथ बनाए गए हैं।

इनमें से कौन सी प्रणाली का उपयोग किया जाता है, निम्नलिखित कारकों पर निर्भर करता है -

  • माइक्रोकंट्रोलर को कितने उपकरणों के साथ डेटा का आदान-प्रदान करना पड़ता है?
  • डेटा एक्सचेंज कितनी तेजी से होना है?
  • इन उपकरणों के बीच की दूरी क्या है?
  • क्या एक साथ डेटा भेजना और प्राप्त करना आवश्यक है?

धारावाहिक संचार से संबंधित सबसे महत्वपूर्ण चीजों में से एक है Protocol, जिसे सख्ती से देखा जाना चाहिए। यह नियमों का एक सेट है, जिसे इस तरह से लागू किया जाना चाहिए कि डिवाइस उन डेटा की सही व्याख्या कर सकें जो वे परस्पर विनिमय करते हैं। सौभाग्य से, Arduino स्वचालित रूप से इस बात का ध्यान रखता है, ताकि प्रोग्रामर / उपयोगकर्ता का काम सरल लेखन (डेटा भेजे जाने के लिए) और पढ़ने (प्राप्त डेटा) तक कम हो जाए।

सीरियल संचार के प्रकार

सीरियल संचार को और अधिक वर्गीकृत किया जा सकता है -

  • Synchronous - जो उपकरण सिंक्रनाइज़ हैं वे एक ही घड़ी का उपयोग करते हैं और उनका समय एक दूसरे के साथ सिंक्रनाइज़ेशन में है।

  • Asynchronous - जो उपकरण एसिंक्रोनस होते हैं उनकी अपनी घड़ियां होती हैं और पिछले राज्य के आउटपुट से चालू होती हैं।

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

उदाहरण के लिए, UART (यूनिवर्सल एसिंक्रोनस रिसिवर ट्रांसमीटर) मॉड्यूल एसिंक्रोनस है।

अतुल्यकालिक धारावाहिक प्रोटोकॉल में कई अंतर्निहित नियम हैं। ये नियम और कुछ नहीं बल्कि तंत्र हैं जो मजबूत और त्रुटि रहित डेटा हस्तांतरण सुनिश्चित करने में मदद करते हैं। ये तंत्र, जो हमें बाहरी घड़ी संकेत से बचने के लिए मिलते हैं, वे हैं -

  • तुल्यकालन बिट्स
  • डेटा बिट्स
  • पैरिटी बिट्स
  • बॉड दर

सिंक्रोनाइज़ेशन बिट्स

सिंक्रनाइज़ेशन बिट्स डेटा के प्रत्येक पैकेट के साथ स्थानांतरित किए गए दो या तीन विशेष बिट्स हैं। वे स्टार्ट बिट और स्टॉप बिट (एस) हैं। उनके नाम के साथ सच है, ये बिट क्रमशः एक पैकेट की शुरुआत और अंत को चिह्नित करते हैं।

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

स्टार्ट बिट को हमेशा 1 से 0 तक जाने वाली एक निष्क्रिय डेटा लाइन द्वारा इंगित किया जाता है, जबकि स्टॉप बिट (एस) 1 पर लाइन को पकड़कर निष्क्रिय स्थिति में वापस संक्रमण करेगा।

डेटा बिट्स

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

पैरिटी बिट्स

उपयोगकर्ता यह चुन सकता है कि समता बिट होनी चाहिए या नहीं, और यदि हाँ, तो समता विषम होनी चाहिए या नहीं। यदि डेटा बिट्स में से 1 की संख्या सम है तो समता बिट 0 है। विषम समता इसके ठीक विपरीत है।

बॉड दर

बॉड दर शब्द का उपयोग प्रति सेकंड [बीपीएस] स्थानांतरित बिट्स की संख्या को दर्शाने के लिए किया जाता है। ध्यान दें कि यह बिट्स को संदर्भित करता है, बाइट्स को नहीं। यह आमतौर पर प्रोटोकॉल द्वारा आवश्यक होता है कि प्रत्येक बाइट को कई नियंत्रण बिट्स के साथ स्थानांतरित किया जाता है। इसका मतलब है कि धारावाहिक डेटा स्ट्रीम में एक बाइट में 11 बिट्स हो सकते हैं। उदाहरण के लिए, यदि बॉड दर 300 बीपीएस है, तो अधिकतम 37 और न्यूनतम 27 बाइट्स प्रति सेकंड स्थानांतरित हो सकते हैं।

अरुडिनो UART

निम्न कोड शुरू होने पर Arduino को हैलो दुनिया भेज देगा।

void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
   Serial.println("hello world"); //print hello world
}

void loop() {

}

Arduino स्केच को Arduino पर अपलोड किए जाने के बाद,

Arduino IDE के शीर्ष दाएं भाग में सीरियल मॉनिटर खोलें ।

सीरियल मॉनिटर के शीर्ष बॉक्स में कुछ भी लिखें और अपने कीबोर्ड पर भेजें या दर्ज करें दबाएं। यह Arduino को बाइट्स की एक श्रृंखला भेजेगा।

निम्न कोड इनपुट के रूप में इसे प्राप्त करता है।

निम्न कोड प्रदान किए गए इनपुट के आधार पर Arduino को आउटपुट प्रदान करेगा।

void setup() {
   Serial.begin(9600); //set up serial library baud rate to 9600
}

void loop() {
   if(Serial.available()) //if number of bytes (characters) available for reading from { 
      serial port
      Serial.print("I received:"); //print I received
      Serial.write(Serial.read()); //send what you read
   }
}

नोटिस जो Serial.print तथा Serial.println जबकि वास्तविक ASCII कोड वापस भेज देंगे Serial.writeवास्तविक पाठ वापस भेज देंगे। अधिक जानकारी के लिए ASCII कोड देखें।

इंटर-इंटीग्रेटेड सर्किट (I2C) एक नई पीढ़ी के माइक्रोकंट्रोलर और विशेष एकीकृत सर्किट के बीच सीरियल डेटा एक्सचेंज के लिए एक प्रणाली है। इसका उपयोग तब किया जाता है जब उनके बीच की दूरी कम होती है (रिसीवर और ट्रांसमीटर आमतौर पर एक ही मुद्रित बोर्ड पर होते हैं)। कनेक्शन दो कंडक्टरों के माध्यम से स्थापित किया गया है। एक का उपयोग डेटा ट्रांसफर के लिए किया जाता है और दूसरे का उपयोग सिंक्रोनाइज़ेशन (क्लॉक सिग्नल) के लिए किया जाता है।

जैसा कि निम्नलिखित आकृति में देखा गया है, एक उपकरण हमेशा एक मास्टर होता है। यह संचार शुरू होने से पहले एक दास चिप को संबोधित करता है। इस तरह, एक माइक्रोकंट्रोलर 112 विभिन्न उपकरणों के साथ संचार कर सकता है। बॉड दर आमतौर पर 100 Kb / सेकंड (मानक मोड) या 10 Kb / सेकंड (धीमी बॉड दर मोड) है। 3.4 एमबी / सेकंड की बॉड दर वाले सिस्टम हाल ही में दिखाई दिए हैं। उपकरणों के बीच की दूरी, जो एक I2C बस पर संचार करती है, कई मीटर तक सीमित है।

बोर्ड I2C पिंस

I2C बस में दो सिग्नल होते हैं - एससीएल और एसडीए। SCL घड़ी संकेत है, और SDA डेटा संकेत है। वर्तमान बस मास्टर हमेशा घड़ी संकेत उत्पन्न करता है। कुछ गुलाम डिवाइस मास्टर को अधिक डेटा भेजने में देरी के लिए कई बार घड़ी को कम कर सकते हैं (या मास्टर को इसे देखने का प्रयास करने से पहले डेटा तैयार करने के लिए अधिक समय की आवश्यकता होती है)। इसे "क्लॉक स्ट्रेचिंग" के रूप में जाना जाता है।

विभिन्न Arduino बोर्डों के लिए पिन निम्नलिखित हैं -

  • ऊनो, प्रो मिनी ए 4 (एसडीए), ए 5 (एससीएल)
  • मेगा, देय 20 (एसडीए), 21 (एससीएल)
  • लियोनार्डो, यूं 2 (एसडीए), 3 (एससीएल)

अरुडिनो आई 2 सी

हमारे पास दो मोड हैं - मास्टर कोड और दास कोड - I2C का उपयोग करके दो Arduino बोर्डों को जोड़ने के लिए। वे हैं -

  • मास्टर ट्रांसमीटर / स्लेव रिसीवर
  • मास्टर रिसीवर / गुलाम ट्रांसमीटर

मास्टर ट्रांसमीटर / स्लेव रिसीवर

आइए अब देखते हैं कि मास्टर ट्रांसमीटर और दास रिसीवर क्या है।

मास्टर ट्रांसमीटर

वायर लाइब्रेरी को आरंभ करने और मास्टर या दास के रूप में I2C बस में शामिल होने के लिए निम्न कार्यों का उपयोग किया जाता है। इसे आम तौर पर केवल एक बार कहा जाता है।

  • Wire.begin(address) - पता हमारे मामले में 7-बिट दास का पता है क्योंकि मास्टर निर्दिष्ट नहीं है और यह मास्टर के रूप में बस में शामिल हो जाएगा।

  • Wire.beginTransmission(address) - दिए गए पते के साथ I2C स्लेव डिवाइस पर ट्रांसमिशन शुरू करें।

  • Wire.write(value) - एक मास्टर से स्लेव डिवाइस तक ट्रांसमिशन के लिए कतार बाइट्स (इन-टू-कॉल टू स्टार्टट्रांसफ्रेम () और एंडट्रांस एडमिशन ())।

  • Wire.endTransmission() - एक गुलाम डिवाइस के लिए एक प्रसारण को समाप्त करता है जो startTransmission () द्वारा शुरू किया गया था और उन बाइट्स को प्रसारित करता है जो तार द्वारा लिखित थे। राइट ()।

Example

#include <Wire.h> //include wire library

void setup() //this will run only once { 
   Wire.begin(); // join i2c bus as master
} 

short age = 0; 

void loop() {   
   Wire.beginTransmission(2); 
   // transmit to device #2
   Wire.write("age is = ");
   Wire.write(age); // sends one byte
   Wire.endTransmission(); // stop transmitting
   delay(1000); 
}

गुलाम पाने वाला

निम्नलिखित कार्यों का उपयोग किया जाता है -

  • Wire.begin(address) - पता 7-बिट दास का पता है।

  • Wire.onReceive(received data handler) - एक दास डिवाइस मास्टर से डेटा प्राप्त होने पर कहा जाने वाला कार्य।

  • Wire.available() - वायर.ट्र्रेड () के साथ पुनर्प्राप्ति के लिए उपलब्ध बाइट्स की संख्या लौटाता है। इसे वायर के अंदर बुलाया जाना चाहिए। (हैंडलर)।

Example

#include <Wire.h> //include wire library

void setup() {  //this will run only once
   Wire.begin(2); // join i2c bus with address #2
   Wire.onReceive(receiveEvent); // call receiveEvent when the master send any thing 
   Serial.begin(9600); // start serial for output to print what we receive 
}

void loop() {   
   delay(250); 
}

//-----this function will execute whenever data is received from master-----//

void receiveEvent(int howMany) { 
   while (Wire.available()>1) // loop through all but the last {
      char c = Wire.read(); // receive byte as a character
      Serial.print(c); // print the character
   }
}

मास्टर रिसीवर / गुलाम ट्रांसमीटर

आइए अब देखते हैं कि मास्टर रिसीवर और दास ट्रांसमीटर क्या है।

मास्टर रिसीवर

मास्टर, अनुरोध करने के लिए क्रमादेशित है, और फिर डेटा के बाइट्स पढ़े जाते हैं जो विशिष्ट रूप से संबोधित दास अर्डुइनो से भेजे जाते हैं।

निम्नलिखित फ़ंक्शन का उपयोग किया जाता है -

Wire.requestFrom(address,number of bytes)- एक दास डिवाइस से बाइट्स का अनुरोध करने के लिए मास्टर द्वारा उपयोग किया जाता है। बाइट्स तब फ़ंक्शंस वायर के साथ फिर से प्राप्त किया जा सकता है। उपलब्ध () और वायर। ट्रेड () फ़ंक्शंस।

Example

#include <Wire.h> //include wire library void setup() { 
   Wire.begin(); // join i2c bus (address optional for master) 
   Serial.begin(9600); // start serial for output
} 

void loop() { 
   Wire.requestFrom(2, 1); // request 1 bytes from slave device #2
   while (Wire.available()) // slave may send less than requested {
      char c = Wire.read(); // receive a byte as character
      Serial.print(c); // print the character
   } 
   delay(500); 
}

गुलाम ट्रांसमीटर

निम्न फ़ंक्शन का उपयोग किया जाता है।

Wire.onRequest(handler) - एक फ़ंक्शन को कहा जाता है जब एक मास्टर इस गुलाम डिवाइस से डेटा का अनुरोध करता है।

Example

#include <Wire.h> 

void setup() { 
   Wire.begin(2); // join i2c bus with address #2
   Wire.onRequest(requestEvent); // register event
} 

Byte x = 0;

void loop() { 
   delay(100); 
} 

// function that executes whenever data is requested by master
// this function is registered as an event, see setup()

void requestEvent() { 
   Wire.write(x); // respond with message of 1 bytes as expected by master
   x++; 
}

एक सीरियल पेरीफेरल इंटरफेस (SPI) बस धारावाहिक संचार के लिए एक प्रणाली है, जो आमतौर पर तीन तक चार कंडक्टरों का उपयोग करती है। एक कंडक्टर का उपयोग डेटा प्राप्त करने के लिए किया जाता है, एक डेटा भेजने के लिए, एक सिंक्रनाइज़ेशन के लिए और एक वैकल्पिक रूप से संचार के लिए एक डिवाइस का चयन करने के लिए किया जाता है। यह एक पूर्ण द्वैध कनेक्शन है, जिसका अर्थ है कि डेटा एक साथ भेजा और प्राप्त किया जाता है। I2C संचार प्रणाली में अधिकतम बॉड दर इससे अधिक है।

बोर्ड एसपीआई पिंस

एसपीआई निम्नलिखित चार तारों का उपयोग करता है -

  • SCK - यह मास्टर द्वारा संचालित धारावाहिक घड़ी है।

  • MOSI - यह मास्टर द्वारा संचालित मास्टर आउटपुट / स्लेव इनपुट है।

  • MISO - यह मास्टर द्वारा संचालित मास्टर इनपुट / स्लेव आउटपुट है।

  • SS - यह गुलाम-चयन तार है।

निम्नलिखित कार्यों का उपयोग किया जाता है। आपको SPI.h को शामिल करना होगा।

  • SPI.begin() - SCK, MOSI और SS को आउटपुट पर सेट करके SPI बस को इनिशियलाइज़ करता है, SCK और MOSI को कम करता है, और SS को हाई करता है।

  • SPI.setClockDivider(divider)- सिस्टम घड़ी के सापेक्ष एसपीआई घड़ी विभक्त सेट करने के लिए। AVR आधारित बोर्डों पर, उपलब्ध डिवाइडर 2, 4, 8, 16, 32, 64 या 128 हैं। डिफ़ॉल्ट सेटिंग SPI_CLOCK_DIV4 है, जो SPI घड़ी को सिस्टम क्लॉक की आवृत्ति के एक-चौथाई में सेट करता है (5 Mhz for) बोर्ड 20 मेगाहर्ट्ज पर)।

  • Divider - यह (SPI_CLOCK_DIV2, SPI_CLOCK_DIV4, SPI_CLOCK_DIV8, SPI_CLOCK_DIV16, SPI_CLOCK_DIV32, SPI_CLOCK_DIV64, SPI_CLOCK_DIV128) हो सकता है।

  • SPI.transfer(val) - एसपीआई स्थानांतरण एक साथ भेजने और प्राप्त करने पर आधारित होता है: प्राप्त डेटा को प्राप्तवैल में लौटा दिया जाता है।

  • SPI.beginTransaction(SPISettings(speedMaximum, dataOrder, dataMode)) - speedMaximum घड़ी, dataOrder (MSBFIRST या LSBFIRST), dataMode (SPI_MODE0, SPI_MODE1, SPI_MODE2, या SPI_MODE3) है।

हमने एसपीआई में ऑपरेशन के चार तरीके इस प्रकार हैं -

  • Mode 0 (the default) - घड़ी आम तौर पर कम (CPOL = 0) होती है, और डेटा को निम्न से उच्च (अग्रणी किनारे) (CPHA = 0) पर संक्रमण के लिए नमूना लिया जाता है।

  • Mode 1 - घड़ी आम तौर पर कम (CPOL = 0) होती है, और डेटा को उच्च से निम्न (अनुगामी किनारे) (CPHA = 1) के संक्रमण पर नमूना लिया जाता है।

  • Mode 2 - क्लॉक सामान्य रूप से उच्च (CPOL = 1) है, और डेटा को उच्च से निम्न (अग्रणी किनारे) (CPHA = 0) पर संक्रमण के लिए नमूना लिया जाता है।

  • Mode 3 - घड़ी आम तौर पर उच्च (CPOL = 1) होती है, और डेटा को निम्न से उच्च (अनुगामी किनारे) (CPHA = 1) के संक्रमण पर नमूना लिया जाता है।

  • SPI.attachInterrupt(handler) - एक दास डिवाइस मास्टर से डेटा प्राप्त होने पर कहा जाने वाला कार्य।

अब, हम दो Arduino UNO बोर्डों को एक साथ जोड़ेंगे; एक गुरु के रूप में और दूसरा दास के रूप में।

  • (एसएस): पिन १०
  • (MOSI): पिन 11
  • (MISO): पिन १२
  • (SCK): पिन 13

जमीन आम है। निम्नलिखित दोनों बोर्डों के बीच संबंध का आरेखात्मक प्रतिनिधित्व है -

आइए एसपीआई के उदाहरणों को मास्टर और एसपीआई को दास के रूप में देखें।

मास्टर के रूप में एस.पी.आई.

उदाहरण

#include <SPI.h>

void setup (void) {
   Serial.begin(115200); //set baud rate to 115200 for usart
   digitalWrite(SS, HIGH); // disable Slave Select
   SPI.begin ();
   SPI.setClockDivider(SPI_CLOCK_DIV8);//divide the clock by 8
}

void loop (void) {
   char c;
   digitalWrite(SS, LOW); // enable Slave Select
   // send test string
   for (const char * p = "Hello, world!\r" ; c = *p; p++) {
      SPI.transfer (c);
      Serial.print(c);
   }
   digitalWrite(SS, HIGH); // disable Slave Select
   delay(2000);
}

SLAVE के रूप में एसपीआई

उदाहरण

#include <SPI.h>
char buff [50];
volatile byte indx;
volatile boolean process;

void setup (void) {
   Serial.begin (115200);
   pinMode(MISO, OUTPUT); // have to send on master in so it set as output
   SPCR |= _BV(SPE); // turn on SPI in slave mode
   indx = 0; // buffer empty
   process = false;
   SPI.attachInterrupt(); // turn on interrupt
}
ISR (SPI_STC_vect) // SPI interrupt routine { 
   byte c = SPDR; // read byte from SPI Data Register
   if (indx < sizeof buff) {
      buff [indx++] = c; // save data in the next index in the array buff
      if (c == '\r') //check for the end of the word
      process = true;
   }
}

void loop (void) {
   if (process) {
      process = false; //reset the process
      Serial.println (buff); //print the array on serial monitor
      indx= 0; //reset button to zero
   }
}

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

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × ब्रेडबोर्ड
  • 1 × अरुडिनो उनो आर 3
  • 1 × एलईडी
  • 1 × 330istor रेसिस्टर
  • 2 × जम्पर

प्रक्रिया

सर्किट आरेख का पालन करें और ब्रेडबोर्ड पर घटकों को हुक करें जैसा कि नीचे दी गई छवि में दिखाया गया है।

Note- एक एलईडी की ध्रुवीयता का पता लगाने के लिए, इसे करीब से देखें। बल्ब के सपाट किनारे की ओर दो पैरों का छोटा होना नकारात्मक टर्मिनल को इंगित करता है।

ब्रेडबोर्ड सॉकेट को ठीक से फिट करने के लिए प्रतिरोधों जैसे घटकों को 90 ° कोण में अपने टर्मिनलों को मोड़ने की आवश्यकता होती है। आप छोटे टर्मिनलों को भी काट सकते हैं।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके नई स्केच फाइल खोलें।

Arduino कोड

/*
   Blink
   Turns on an LED on for one second, then off for one second, repeatedly.
*/

// the setup function runs once when you press reset or power the board

void setup() {  // initialize digital pin 13 as an output.
   pinMode(2, OUTPUT);
}

// the loop function runs over and over again forever

void loop() {
   digitalWrite(2, HIGH); // turn the LED on (HIGH is the voltage level)
   delay(1000); // wait for a second
   digitalWrite(2, LOW); // turn the LED off by making the voltage LOW
   delay(1000); // wait for a second
}

नोट करने के लिए कोड

pinMode(2, OUTPUT)- इससे पहले कि आप एक Arduino के पिन का उपयोग कर सकें, आपको Arduino Uno R3 को यह बताने की आवश्यकता है कि यह एक INPUT या OUTPUT है या नहीं। हम ऐसा करने के लिए pinMode () नामक एक अंतर्निहित "फ़ंक्शन" का उपयोग करते हैं।

digitalWrite(2, HIGH) - जब आप एक पिन को OUTPUT के रूप में उपयोग कर रहे हैं, तो आप इसे हाई (आउटपुट 5 वोल्ट), या LOW (आउटपुट 0 वोल्ट) होने के लिए कमांड कर सकते हैं।

परिणाम

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

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

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × ब्रेडबोर्ड
  • 1 × अरुडिनो उनो आर 3
  • 1 × एलईडी
  • 1 × 330istor रेसिस्टर
  • 2 × जम्पर

प्रक्रिया

सर्किट आरेख का पालन करें और ब्रेडबोर्ड पर घटकों को हुक करें जैसा कि नीचे दी गई छवि में दिखाया गया है।

Note- एक एलईडी की ध्रुवीयता का पता लगाने के लिए, इसे करीब से देखें। बल्ब के सपाट किनारे की ओर दो पैरों का छोटा होना नकारात्मक टर्मिनल को इंगित करता है।

ब्रेडबोर्ड सॉकेट को ठीक से फिट करने के लिए प्रतिरोधों जैसे घटकों को 90 ° कोण में अपने टर्मिनलों को मोड़ने की आवश्यकता होती है। आप छोटे टर्मिनलों को भी काट सकते हैं।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके नई स्केच फाइल खोलें।

Arduino कोड

/*
   Fade
   This example shows how to fade an LED on pin 9 using the analogWrite() function.

   The analogWrite() function uses PWM, so if you want to change the pin you're using, be
   sure to use another PWM capable pin. On most Arduino, the PWM pins are identified with
   a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.
*/

int led = 9; // the PWM pin the LED is attached to
int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by
// the setup routine runs once when you press reset:

void setup() {
   // declare pin 9 to be an output:
   pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:

void loop() {
   // set the brightness of pin 9:
   analogWrite(led, brightness);
   // change the brightness for next time through the loop:
   brightness = brightness + fadeAmount;
   // reverse the direction of the fading at the ends of the fade:
   if (brightness == 0 || brightness == 255) {
      fadeAmount = -fadeAmount ;
   }
   // wait for 30 milliseconds to see the dimming effect
   delay(300);
}

नोट करने के लिए कोड

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

एलईडी को बंद करने और चालू करने के लिए, चक्र को पूरा करने के लिए धीरे-धीरे पीडब्लूएम मान को 0 से बढ़ाएं (सभी तरह से बंद) से 255 (सभी तरह से), और फिर वापस 0 पर। ऊपर दिए गए स्केच में, PWM मान चमक नामक एक चर का उपयोग करके सेट किया गया है। हर बार लूप के माध्यम से, यह चर के मूल्य से बढ़ता हैfadeAmount।

यदि चमक अपने मूल्य (या तो 0 या 255) के चरम पर है, तो fadeAmount को इसके नकारात्मक में बदल दिया जाता है। दूसरे शब्दों में, यदि fadeAmount 5 है, तो इसे -5 पर सेट किया जाता है। यदि यह -5 है, तो इसे 5 पर सेट किया जाता है। अगली बार लूप के माध्यम से, यह परिवर्तन चमक को दिशा बदलने के साथ-साथ बनाता है।

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

परिणाम

आपको अपने एलईडी चमक को धीरे-धीरे बदलना चाहिए।

यह उदाहरण आपको दिखाएगा कि एनालॉग पिन पर एनालॉग इनपुट को कैसे पढ़ा जाए। 0. इनपुट को एनालॉगरेड () से वोल्टेज में परिवर्तित किया जाता है, और Arduino Software (IDE) के सीरियल मॉनिटर पर प्रिंट किया जाता है।

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × ब्रेडबोर्ड
  • 1 × अरुडिनो उनो आर 3
  • 1 × 5K चर रोकनेवाला (पोटेंशियोमीटर)
  • 2 × जम्पर

प्रक्रिया

सर्किट आरेख का पालन करें और ब्रेडबोर्ड पर घटकों को हुक करें जैसा कि नीचे दी गई छवि में दिखाया गया है।

तनाव नापने का यंत्र

एक पोटेंशियोमीटर (या पॉट) एक साधारण इलेक्ट्रो-मैकेनिकल ट्रांसड्यूसर है। यह प्रतिरोध के परिवर्तन में इनपुट ऑपरेटर से रोटरी या रैखिक गति को परिवर्तित करता है। यह परिवर्तन है (या हो सकता है) एक हाई-फाई सिस्टम की मात्रा से किसी भी विशाल कंटेनर जहाज की दिशा को नियंत्रित करने के लिए उपयोग किया जाता है।

जैसा कि हम जानते हैं कि पॉट मूल रूप से एक रिओस्तात (अनिवार्य रूप से एक चर वायरवाउंड रोकनेवाला) के रूप में जाना जाता था। उपलब्ध बर्तनों की विविधता अब काफी आश्चर्यजनक है, और यह शुरुआती (विशेष रूप से) के लिए बहुत कठिन हो सकता है कि किसी दिए गए कार्य के लिए कौन सा प्रकार उपयुक्त है। कुछ अलग पॉट प्रकार, जो सभी एक ही कार्य के लिए उपयोग किए जा सकते हैं, कार्य को कठिन बना देता है।

बाईं ओर की छवि एक पॉट के मानक योजनाबद्ध प्रतीक को दिखाती है। दाईं ओर की छवि पोटेंशियोमीटर है।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

Arduino कोड

/*
   ReadAnalogVoltage
   Reads an analog input on pin 0, converts it to voltage, 
   and prints the result to the serial monitor.
   Graphical representation is available using serial plotter (Tools > Serial Plotter menu)
   Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V and ground.
*/

// the setup routine runs once when you press reset:

void setup() {
   // initialize serial communication at 9600 bits per second:
   Serial.begin(9600);
}

// the loop routine runs over and over again forever:

void loop() {
   // read the input on analog pin 0:
   int sensorValue = analogRead(A0);
   // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
   float voltage = sensorValue * (5.0 / 1023.0);
   // print out the value you read:
   Serial.println(voltage);
}

नोट करने के लिए कोड

नीचे दिए गए प्रोग्राम या स्केच में, सेटअप फ़ंक्शन में आप जो पहली चीज करते हैं, वह धारावाहिक संचार शुरू होता है, 9600 बिट्स प्रति सेकंड, आपके बोर्ड और आपके कंप्यूटर के बीच लाइन के साथ -

Serial.begin(9600);

अपने कोड के मुख्य लूप में, आपको अपने पोटेंशियोमीटर से आने वाले प्रतिरोध मान (जो 0 और 1023 के बीच होगा, एक इंट डेटेटाइप के लिए एकदम सही होगा) को स्टोर करने के लिए एक वैरिएबल स्थापित करने की आवश्यकता है -

int sensorValue = analogRead(A0);

मानों को 0-1023 से एक सीमा तक बदलने के लिए जो वोल्टेज से मेल खाती है, पिन पढ़ रहा है, आपको एक और चर, एक फ्लोट बनाने और थोड़ी गणना करने की आवश्यकता है। 0.0 और 5.0 के बीच की संख्याओं को मापने के लिए, 5.0 को 1023.0 से विभाजित करें और सेंसरवैल्यू द्वारा गुणा करें -

float voltage= sensorValue * (5.0 / 1023.0);

अंत में, आपको इस जानकारी को अपने सीरियल विंडो पर प्रिंट करना होगा। आप अपने अंतिम कोड लाइन में Serial.println () कमांड के साथ ऐसा कर सकते हैं -

Serial.println(voltage)

अब, शीर्ष ग्रीन बार के दाईं ओर आइकन पर क्लिक करके या Ctrl + Shift + M दबाकर Arduino IDE में सीरियल मॉनिटर खोलें।

परिणाम

आपको 0.0 - 5.0 तक की संख्या की एक स्थिर धारा दिखाई देगी। जैसा कि आप पॉट को चालू करते हैं, मान बदल जाएंगे, पिन ए 0 पर वोल्टेज के अनुरूप।

यह उदाहरण आपको दिखाता है कि एनालॉग पिन 0 पर एनालॉग इनपुट को कैसे पढ़ा जाए, analogRead () से वोल्टेज में मानों को परिवर्तित करें, और इसे Arduino Software (IDE) के सीरियल मॉनिटर पर प्रिंट करें।

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × ब्रेडबोर्ड
  • 1 × अरुडिनो उनो आर 3
  • 1 × 5 k ओम चर रोकनेवाला (पोटेंशियोमीटर)
  • 2 × जम्पर
  • 8 × एलईडी या आप उपयोग कर सकते हैं (एलईडी बार ग्राफ डिस्प्ले जैसा कि नीचे की छवि में दिखाया गया है)

प्रक्रिया

सर्किट आरेख का पालन करें और ब्रेडबोर्ड पर घटकों को हुक करें जैसा कि नीचे दी गई छवि में दिखाया गया है।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

10 सेगमेंट एलईडी बार ग्राफ

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

वे पीले, लाल और हरे रंगों में भी उपलब्ध हैं।

Note- इन बार ग्राफ़ पर पिन आउट अलग हो सकता है जो डेटाशीट पर सूचीबद्ध है। डिवाइस को 180 डिग्री पर घुमाने से परिवर्तन सही हो जाएगा, जिससे पिन 11 लाइन में पहला पिन बन जाएगा।

Arduino कोड

/*
   LED bar graph
   Turns on a series of LEDs based on the value of an analog sensor. 
   This is a simple way to make a bar graph display. 
   Though this graph uses 8LEDs, you can use any number by
      changing the LED count and the pins in the array.
   This method can be used to control any series of digital
      outputs that depends on an analog input.
*/

// these constants won't change:
const int analogPin = A0; // the pin that the potentiometer is attached to
const int ledCount = 8; // the number of LEDs in the bar graph
int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9}; // an array of pin numbers to which LEDs are attached

void setup() {
   // loop over the pin array and set them all to output:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      pinMode(ledPins[thisLed], OUTPUT);
   }
}

void loop() {
   // read the potentiometer:
   int sensorReading = analogRead(analogPin);
   // map the result to a range from 0 to the number of LEDs:
   int ledLevel = map(sensorReading, 0, 1023, 0, ledCount);
   // loop over the LED array:
   for (int thisLed = 0; thisLed < ledCount; thisLed++) {
      // if the array element's index is less than ledLevel,
      // turn the pin for this element on:
      if (thisLed < ledLevel) {
         digitalWrite(ledPins[thisLed], HIGH);
      }else { // turn off all pins higher than the ledLevel:
         digitalWrite(ledPins[thisLed], LOW);
      }
   }
}

नोट करने के लिए कोड

स्केच इस तरह से काम करता है: पहले, आप इनपुट पढ़ते हैं। आप आउटपुट मान को मैप करते हैं, इस मामले में दस एल ई डी। फिर आपने एक सेट कियाfor-loopआउटपुट पर पुनरावृति करने के लिए। यदि श्रृंखला में आउटपुट की संख्या मैप की गई इनपुट रेंज से कम है, तो आप इसे चालू करते हैं। यदि नहीं, तो आप इसे बंद कर देते हैं।

परिणाम

जब आप एनालॉग रीडिंग का मान बढ़ाते हैं तो आप एक-एक करके एलईडी को चालू करते हैं और रीडिंग कम होने पर एक-एक करके बंद कर देते हैं।

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

Warning - जब आप का उपयोग करें Keyboard.print()कमांड, Arduino आपके कंप्यूटर के कीबोर्ड को संभाल लेता है। यह सुनिश्चित करने के लिए कि आप इस फ़ंक्शन के साथ स्केच चलाते समय अपने कंप्यूटर का नियंत्रण नहीं खोते हैं, आप Keyboard.print () को कॉल करने से पहले एक विश्वसनीय नियंत्रण प्रणाली स्थापित कर सकते हैं। यह स्केच केवल एक कीबोर्ड कमांड भेजने के लिए डिज़ाइन किया गया है, क्योंकि पिन को जमीन पर खींचा गया है।

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × ब्रेडबोर्ड
  • 1 × अरुडिनो लियोनार्डो, माइक्रो या ड्यू बोर्ड
  • 1 × पुशबटन
  • 1 × जम्पर

प्रक्रिया

सर्किट आरेख का पालन करें और ब्रेडबोर्ड पर घटकों को हुक करें जैसा कि नीचे की छवि में दिखाया गया है।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

इस उदाहरण के लिए, आपको Arduino IDE 1.6.7 का उपयोग करने की आवश्यकता है

Note- आपको अपनी Arduino लाइब्रेरी फ़ाइल में कीबोर्ड लाइब्रेरी को शामिल करना होगा। निम्न स्क्रीनशॉट में दिखाए गए नाम लाइब्रेरी (हाइलाइट) के साथ फाइल के अंदर कीपैड लाइब्रेरी फ़ाइल को कॉपी और पेस्ट करें।

Arduino कोड

/*
   Keyboard logout
   This sketch demonstrates the Keyboard library.
   When you connect pin 2 to ground, it performs a logout.
   It uses keyboard combinations to do this, as follows:
   On Windows, CTRL-ALT-DEL followed by ALT-l
   On Ubuntu, CTRL-ALT-DEL, and ENTER
   On OSX, CMD-SHIFT-q
   To wake: Spacebar.
   Circuit:
   * Arduino Leonardo or Micro
   * wire to connect D2 to ground.
*/

#define OSX 0
#define WINDOWS 1
#define UBUNTU 2

#include "Keyboard.h"

// change this to match your platform:
int platform = WINDOWS;

void setup() {
   // make pin 2 an input and turn on the
   // pullup resistor so it goes high unless
   // connected to ground:
   
   pinMode(2, INPUT_PULLUP);
   Keyboard.begin();
}

void loop() {
   while (digitalRead(2) == HIGH) {
      // do nothing until pin 2 goes low
      delay(500);
   }
   
   delay(1000);
   
   switch (platform) {
      case OSX:
      Keyboard.press(KEY_LEFT_GUI);
	  
      // Shift-Q logs out:
      Keyboard.press(KEY_LEFT_SHIFT);
      Keyboard.press('Q');
      delay(100);
	  
      // enter:
      Keyboard.write(KEY_RETURN);
      break;
	  
      case WINDOWS:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
      //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
      case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
	  
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
   // do nothing:
   while (true);
}

Keyboard.releaseAll();

   // enter:
      Keyboard.write(KEY_RETURN);
      break;
      case WINDOWS:
	  
   // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(100);
      Keyboard.releaseAll();
	  
   //ALT-l:
      delay(2000);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press('l');
      Keyboard.releaseAll();
      break;
	  
   case UBUNTU:
      // CTRL-ALT-DEL:
      Keyboard.press(KEY_LEFT_CTRL);
      Keyboard.press(KEY_LEFT_ALT);
      Keyboard.press(KEY_DELETE);
      delay(1000);
      Keyboard.releaseAll();
	  
      // Enter to confirm logout:
      Keyboard.write(KEY_RETURN);
      break;
   }
   
// do nothing:
   while (true);
}

नोट करने के लिए कोड

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

जबकि स्केच चल रहा है, बटन दबाकर पिन 2 को जमीन से जोड़ा जाएगा और बोर्ड यूएसबी कनेक्टेड पीसी को लॉगआउट अनुक्रम भेजेगा।

परिणाम

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

यह लॉगआउट करने के लिए निम्नलिखित कीबोर्ड संयोजनों का उपयोग करता है -

  • पर Windows, CTRL-ALT-DEL के बाद ALT-l

  • पर Ubuntu, CTRL-ALT-DEL, और ENTER

  • पर OSX, CMD-SHIFT-q

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

Warning - जब आप का उपयोग करें Keyboard.print()कमांड, Arduino आपके कंप्यूटर के कीबोर्ड को संभालता है। यह सुनिश्चित करने के लिए कि आप इस फ़ंक्शन के साथ स्केच चलाते समय अपने कंप्यूटर का नियंत्रण नहीं खोते हैं, कॉल करने से पहले एक विश्वसनीय नियंत्रण प्रणाली स्थापित करेंKeyboard.print()। इस स्केच में कीबोर्ड को टॉगल करने के लिए एक पुशबटन शामिल है, ताकि यह बटन दबाए जाने के बाद ही चले।

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × ब्रेडबोर्ड
  • 1 × अरुडिनो लियोनार्डो, माइक्रो या ड्यू बोर्ड
  • 1 × क्षणिक पुशबटन
  • 1 × 10 k ओम अवरोधक

प्रक्रिया

सर्किट आरेख का पालन करें और ब्रेडबोर्ड पर घटकों को हुक करें जैसा कि नीचे दी गई छवि में दिखाया गया है।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

Arduino कोड

/*
   Keyboard Message test For the Arduino Leonardo and Micro,
      Sends a text string when a button is pressed.
   The circuit:
   * pushbutton attached from pin 4 to +5V
   * 10-kilohm resistor attached from pin 4 to ground
*/

#include "Keyboard.h"
const int buttonPin = 4; // input pin for pushbutton
int previousButtonState = HIGH; // for checking the state of a pushButton
int counter = 0; // button push counter

void setup() {
   pinMode(buttonPin, INPUT); // make the pushButton pin an input:
   Keyboard.begin(); // initialize control over the keyboard:
}

void loop() {
   int buttonState = digitalRead(buttonPin); // read the pushbutton:
   if ((buttonState != previousButtonState)&& (buttonState == HIGH)) // and it's currently pressed: {
      // increment the button counter
      counter++;
      // type out a message
      Keyboard.print("You pressed the button ");
      Keyboard.print(counter);
      Keyboard.println(" times.");
   }
   // save the current button state for comparison next time:
   previousButtonState = buttonState;
}

नोट करने के लिए कोड

Arduino पर 4 पिन करने के लिए पुशबटन के एक टर्मिनल को संलग्न करें। 5V करने के लिए अन्य पिन संलग्न करें। जमीन के लिए एक संदर्भ प्रदान करते हुए, पुल-डाउन के रूप में अवरोधक का उपयोग करें, इसे पिन 4 से जमीन पर संलग्न करके।

एक बार जब आप अपने बोर्ड को प्रोग्राम कर लें, तो USB केबल को अनप्लग करें, टेक्स्ट एडिटर खोलें और टेक्स्ट कर्सर को टाइपिंग एरिया में रखें। USB के माध्यम से अपने कंप्यूटर पर बोर्ड को फिर से कनेक्ट करें और दस्तावेज़ में लिखने के लिए बटन दबाएं।

परिणाम

किसी भी पाठ संपादक का उपयोग करके, वह Arduino के माध्यम से भेजे गए पाठ को प्रदर्शित करेगा।

माउस लाइब्रेरी का उपयोग करके, आप एक Arduino Leonardo, Micro या Due के साथ कंप्यूटर के ऑनस्क्रीन कर्सर को नियंत्रित कर सकते हैं।

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

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

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

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × ब्रेडबोर्ड
  • 1 × अरुडिनो लियोनार्डो, माइक्रो या ड्यू बोर्ड
  • 5 × 10 k ओम अवरोधक
  • 5 × क्षणिक पुशबुटन

प्रक्रिया

सर्किट आरेख का पालन करें और ब्रेडबोर्ड पर घटकों को हुक करें जैसा कि नीचे की छवि में दिखाया गया है।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

इस उदाहरण के लिए, आपको Arduino IDE 1.6.7 का उपयोग करने की आवश्यकता है

Arduino कोड

/*
   Button Mouse Control
   For Leonardo and Due boards only .Controls the mouse from 
   five pushbuttons on an Arduino Leonardo, Micro or Due.
   Hardware:
   * 5 pushbuttons attached to D2, D3, D4, D5, D6
   The mouse movement is always relative. This sketch reads
   four pushbuttons, and uses them to set the movement of the mouse.
   WARNING: When you use the Mouse.move() command, the Arduino takes
   over your mouse! Make sure you have control before you use the mouse commands.
*/

#include "Mouse.h"
// set pin numbers for the five buttons:
const int upButton = 2;
const int downButton = 3;
const int leftButton = 4;
const int rightButton = 5;
const int mouseButton = 6;
int range = 5; // output range of X or Y movement; affects movement speed
int responseDelay = 10; // response delay of the mouse, in ms

void setup() {
   // initialize the buttons' inputs:
   pinMode(upButton, INPUT);
   pinMode(downButton, INPUT);
   pinMode(leftButton, INPUT);
   pinMode(rightButton, INPUT);
   pinMode(mouseButton, INPUT);
   // initialize mouse control:
   Mouse.begin();
}

void loop() {
   // read the buttons:
   int upState = digitalRead(upButton);
   int downState = digitalRead(downButton);
   int rightState = digitalRead(rightButton);
   int leftState = digitalRead(leftButton);
   int clickState = digitalRead(mouseButton);
   // calculate the movement distance based on the button states:
   int xDistance = (leftState - rightState) * range;
   int yDistance = (upState - downState) * range;
   // if X or Y is non-zero, move:
   if ((xDistance != 0) || (yDistance != 0)) {
      Mouse.move(xDistance, yDistance, 0);
   }

   // if the mouse button is pressed:
   if (clickState == HIGH) {
      // if the mouse is not pressed, press it:
      if (!Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.press(MOUSE_LEFT);
      }
   } else {                           // else the mouse button is not pressed:
      // if the mouse is pressed, release it:
      if (Mouse.isPressed(MOUSE_LEFT)) {
         Mouse.release(MOUSE_LEFT);
      }
   }
   // a delay so the mouse does not move too fast:
   delay(responseDelay);
}

नोट करने के लिए कोड

अपने बोर्ड को माइक्रो-यूएसबी केबल से अपने कंप्यूटर से कनेक्ट करें। बटन 2 से 6 पिन से डिजिटल इनपुट से जुड़े हैं। सुनिश्चित करें कि आप 10k पुल-डाउन प्रतिरोधों का उपयोग करते हैं।

यह उदाहरण सीरियल पोर्ट से आने वाली बाइट के लिए सुनता है। जब प्राप्त होता है, बोर्ड कंप्यूटर पर एक कीस्ट्रोक भेजता है। भेजे गए कीस्ट्रोक जो प्राप्त होता है उससे एक अधिक होता है, इसलिए यदि आप सीरियल मॉनिटर से "a" भेजते हैं, तो आप कंप्यूटर से जुड़े बोर्ड से "b" प्राप्त करेंगे। एक "1" एक "2" और इतने पर वापस आ जाएगा।

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

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × अरुडिनो लियोनार्डो, माइक्रो या ड्यू बोर्ड

प्रक्रिया

बस यूएसबी केबल का उपयोग करके अपने बोर्ड को कंप्यूटर से कनेक्ट करें।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

Notes- आपको अपने Arduino लाइब्रेरी फ़ाइल में कीपैड लाइब्रेरी को शामिल करना होगा। फ़ाइल के अंदर कीपैड लाइब्रेरी फ़ाइल को 'लाइब्रेरीज़' नाम से कॉपी और पेस्ट करें, जिसे पीले रंग के साथ हाइलाइट किया गया है।

Arduino कोड

/*
   Keyboard test
   For the Arduino Leonardo, Micro or Due Reads
      a byte from the serial port, sends a keystroke back. 
   The sent keystroke is one higher than what's received, e.g. if you send a, you get b, send
      A you get B, and so forth.
   The circuit:
   * none
*/

#include "Keyboard.h"

void setup() {
   // open the serial port:
   Serial.begin(9600);
   // initialize control over the keyboard:
   Keyboard.begin();
}

void loop() {
   // check for incoming serial data:
   if (Serial.available() > 0) {
      // read incoming serial data:
      char inChar = Serial.read();
      // Type the next ASCII value from what you received:
      Keyboard.write(inChar + 1);
   }
}

नोट करने के लिए कोड

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

परिणाम

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

इस अनुभाग में, हम सीखेंगे कि विभिन्न सेंसरों के साथ हमारे Arduino बोर्ड को कैसे इंटरफ़ेस करें। हम निम्नलिखित सेंसर पर चर्चा करेंगे -

  • आर्द्रता सेंसर (DHT22)
  • तापमान संवेदक (LM35)
  • पानी डिटेक्टर सेंसर (सरल पानी ट्रिगर)
  • पीर सेंसर
  • अतिध्वनि संवेदक
  • GPS

आर्द्रता सेंसर (DHT22)

DHT-22 (जिसे AM2302 भी कहा जाता है) एक डिजिटल-आउटपुट, सापेक्षिक आर्द्रता और तापमान सेंसर है। यह आस-पास की हवा को मापने के लिए एक कैपेसिटिव ह्यूमिडिटी सेंसर और एक थर्मिस्टर का उपयोग करता है, और डेटा पिन पर एक डिजिटल सिग्नल भेजता है।

इस उदाहरण में, आप सीखेंगे कि Arduino UNO के साथ इस सेंसर का उपयोग कैसे करें। कमरे के तापमान और आर्द्रता को सीरियल मॉनिटर पर मुद्रित किया जाएगा।

DHT-22 सेंसर

कनेक्शन सरल हैं। 3-5V शक्ति के लिए बाईं ओर पहला पिन, डेटा इनपुट पिन के लिए दूसरा पिन और जमीन पर दाईं-सबसे पिन।

तकनीकी जानकारी

  • Power - 3-5 वी

  • Max Current - 2.5mA

  • Humidity - 0-100%, 2-5% सटीकता

  • Temperature - 40 से 80 ° C, C 0.5 ° C सटीकता

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × ब्रेडबोर्ड
  • 1 × अरुडिनो उनो आर 3
  • 1 × DHT22
  • 1 × 10K ओम रोकनेवाला

प्रक्रिया

सर्किट आरेख का पालन करें और ब्रेडबोर्ड पर घटकों को हुक करें जैसा कि नीचे की छवि में दिखाया गया है।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

Arduino कोड

// Example testing sketch for various DHT humidity/temperature sensors

#include "DHT.h"
#define DHTPIN 2 // what digital pin we're connected to
// Uncomment whatever type you're using!
//#define DHTTYPE DHT11 // DHT 11
#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
//#define DHTTYPE DHT21 // DHT 21 (AM2301)
// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
// Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to
// tweak the timings for faster processors. This parameter is no longer needed
// as the current DHT reading algorithm adjusts itself to work on faster procs.
DHT dht(DHTPIN, DHTTYPE);

void setup() {
   Serial.begin(9600);
   Serial.println("DHTxx test!");
   dht.begin();
}

void loop() {
   delay(2000); // Wait a few seconds between measurements
   float h = dht.readHumidity();
   // Reading temperature or humidity takes about 250 milliseconds!
   float t = dht.readTemperature();
   // Read temperature as Celsius (the default)
   float f = dht.readTemperature(true);
   // Read temperature as Fahrenheit (isFahrenheit = true)
   // Check if any reads failed and exit early (to try again).
   if (isnan(h) || isnan(t) || isnan(f)) {
      Serial.println("Failed to read from DHT sensor!");
      return;
   }
   
   // Compute heat index in Fahrenheit (the default)
   float hif = dht.computeHeatIndex(f, h);
   // Compute heat index in Celsius (isFahreheit = false)
   float hic = dht.computeHeatIndex(t, h, false);
   Serial.print ("Humidity: ");
   Serial.print (h);
   Serial.print (" %\t");
   Serial.print ("Temperature: ");
   Serial.print (t);
   Serial.print (" *C ");
   Serial.print (f);
   Serial.print (" *F\t");
   Serial.print ("Heat index: ");
   Serial.print (hic);
   Serial.print (" *C ");
   Serial.print (hif);
   Serial.println (" *F");
}

नोट करने के लिए कोड

DHT22 सेंसर में चार टर्मिनल (V cc , DATA, NC, GND) हैं, जो बोर्ड से जुड़े हैं -

  • Arduino पिन नंबर 2 को DATA पिन
  • Arduino बोर्ड के 5 वोल्ट तक वी सीसी पिन
  • Arduino बोर्ड की जमीन पर GND पिन
  • हमें DATA और V cc पिन के बीच 10k ओम रेसिस्टर (पुल अप रेज़र) को कनेक्ट करना होगा

एक बार हार्डवेयर कनेक्शन हो जाने के बाद, आपको पहले वर्णित के अनुसार अपनी Arduino लाइब्रेरी फ़ाइल में DHT22 लाइब्रेरी को जोड़ना होगा।

परिणाम

आप सीरियल पोर्ट मॉनिटर पर तापमान और आर्द्रता का प्रदर्शन देखेंगे जो हर 2 सेकंड में अपडेट किया जाता है।

तापमान सेंसर LM35 श्रृंखला सटीक एकीकृत-सर्किट तापमान डिवाइस हैं जिसमें एक आउटपुट वोल्टेज रैखिक रूप से सेंटीग्रेड तापमान के लिए आनुपातिक होता है।

केल्विन में कैलिब्रेटेड रैखिक तापमान सेंसर पर LM35 डिवाइस का एक फायदा है, क्योंकि उपयोगकर्ता को सुविधाजनक सेंटीग्रेड स्केलिंग प्राप्त करने के लिए आउटपुट से एक बड़े स्थिर वोल्टेज को घटाना आवश्यक नहीं है। LM35 डिवाइस को कमरे के तापमान पर ies C ° C की विशिष्ट सटीकता प्रदान करने के लिए किसी बाहरी अंशांकन या ट्रिमिंग की आवश्यकता नहीं होती है और पूर्ण −55 ° C से 150 ° C तापमान सीमा पर not C ° C होता है।

तकनीकी निर्देश

  • सीधे सेल्सियस (सेंटीग्रेड) में कैलिब्रेटेड
  • रैखिक + 10-mV / ° C स्केल कारक
  • 0.5 डिग्री सेल्सियस सुनिश्चित सटीकता (25 डिग्री सेल्सियस पर)
  • पूर्ण ated55 ° C से 150 ° C श्रेणी के लिए रेटेड
  • दूरस्थ अनुप्रयोगों के लिए उपयुक्त है

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × ब्रेडबोर्ड
  • 1 × अरुडिनो उनो आर 3
  • 1 × LM35 सेंसर

प्रक्रिया

सर्किट आरेख का पालन करें और ब्रेडबोर्ड पर घटकों को हुक करें जैसा कि नीचे दी गई छवि में दिखाया गया है।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

Arduino कोड

float temp;
int tempPin = 0;

void setup() {
   Serial.begin(9600);
}

void loop() {
   temp = analogRead(tempPin);
   // read analog volt from sensor and save to variable temp
   temp = temp * 0.48828125;
   // convert the analog volt to its temperature equivalent
   Serial.print("TEMPERATURE = ");
   Serial.print(temp); // display temperature value
   Serial.print("*C");
   Serial.println();
   delay(1000); // update sensor reading each one second
}

नोट करने के लिए कोड

LM35 सेंसर में तीन टर्मिनल हैं - V s , V आउट और GND। हम सेंसर को इस प्रकार कनेक्ट करेंगे -

  • अपने Arduino बोर्ड पर + V s + 5v कनेक्ट करें ।
  • कनेक्ट वी बाहर Analog0 या A0 के लिए Arduino बोर्ड पर।
  • Arduino पर GND के साथ GND कनेक्ट करें।

डिजिटल कनवर्टर (ADC) के अनुरूप सूत्र ADC मान = नमूना * 1024 / संदर्भ वोल्टेज (+ 5v) के आधार पर एनालॉग मानों को एक डिजिटल सन्निकटन में परिवर्तित करता है। इसलिए +5 वोल्ट संदर्भ के साथ, डिजिटल सन्निकटन इनपुट वोल्टेज * 205 के बराबर होगा।

परिणाम

आप धारावाहिक पोर्ट मॉनिटर पर तापमान प्रदर्शन देखेंगे जो हर सेकंड अपडेट किया जाता है।

वॉटर सेंसर ईंट को पानी का पता लगाने के लिए डिज़ाइन किया गया है, जिसका उपयोग व्यापक रूप से संवेदन वर्षा, जल स्तर और यहां तक ​​कि तरल रिसाव में भी किया जा सकता है।

एक रिसाव, फैल, बाढ़, बारिश, आदि का पता लगाने के लिए एक Arduino के लिए पानी के सेंसर को जोड़ना एक शानदार तरीका है। इसका उपयोग उपस्थिति, स्तर, मात्रा और / या पानी की अनुपस्थिति का पता लगाने के लिए किया जा सकता है। जबकि इसका उपयोग आपको अपने पौधों को पानी देने के लिए याद दिलाने के लिए किया जा सकता है, इसके लिए बेहतर ग्रोव सेंसर है। संवेदक में उजागर निशान की एक सरणी होती है, जो पानी का पता चलने पर कम पढ़ता है।

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

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × ब्रेडबोर्ड
  • 1 × अरुडिनो उनो आर 3
  • 1 × पानी सेंसर
  • 1 × नेतृत्व किया
  • 1 × 330 ओम अवरोधक

प्रक्रिया

सर्किट आरेख का पालन करें और ब्रेडबोर्ड पर घटकों को हुक करें जैसा कि नीचे दी गई छवि में दिखाया गया है।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

Arduino कोड

#define Grove_Water_Sensor 8 // Attach Water sensor to Arduino Digital Pin 8
#define LED 9 // Attach an LED to Digital Pin 9 (or use onboard LED)

void setup() {
   pinMode(Grove_Water_Sensor, INPUT); // The Water Sensor is an Input
   pinMode(LED, OUTPUT); // The LED is an Output
}

void loop() {
   /* The water sensor will switch LOW when water is detected.
   Get the Arduino to illuminate the LED and activate the buzzer
   when water is detected, and switch both off when no water is present */
   if( digitalRead(Grove_Water_Sensor) == LOW) {
      digitalWrite(LED,HIGH);
   }else {
      digitalWrite(LED,LOW);
   }
}

नोट करने के लिए कोड

पानी के सेंसर में तीन टर्मिनल होते हैं - एस, वी आउट (+), और जीएनडी (-)। सेंसर को निम्नानुसार कनेक्ट करें -

  • अपने Arduino बोर्ड पर + V s + 5v कनेक्ट करें ।
  • Arduino बोर्ड पर S को डिजिटल पिन नंबर 8 से कनेक्ट करें।
  • Arduino पर GND के साथ GND कनेक्ट करें।
  • Arduino बोर्ड में LED को डिजिटल पिन नंबर 9 से कनेक्ट करें।

जब सेंसर पानी का पता लगाता है, तो Arduino पर पिन 8 LOW हो जाता है और फिर Arduino पर एलईडी चालू होता है।

परिणाम

जब सेंसर पानी का पता लगाएगा तो आप इंडिकेशन एलईडी टर्न ऑन देखेंगे।

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

PIR सेंसर के फायदे निम्नलिखित हैं -

  • आकार में छोटा
  • वाइड लेंस रेंज
  • इंटरफ़ेस करने के लिए आसान है
  • Inexpensive
  • Low-power
  • प्रयोग करने में आसान
  • बाहर मत पहनो

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

पीआईआर में समायोज्य सेटिंग्स होती हैं और 3-पिन ग्राउंड / आउट / पावर पैड में एक हेडर स्थापित होता है।

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

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × ब्रेडबोर्ड
  • 1 × अरुडिनो उनो आर 3
  • 1 × पीर सेंसर (MQ3)

प्रक्रिया

सर्किट आरेख का पालन करें और कनेक्शन बनाएं जैसा कि नीचे की छवि में दिखाया गया है।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

Arduino कोड

#define pirPin 2
int calibrationTime = 30;
long unsigned int lowIn;
long unsigned int pause = 5000;
boolean lockLow = true;
boolean takeLowTime;
int PIRValue = 0;

void setup() {
   Serial.begin(9600);
   pinMode(pirPin, INPUT);
}

void loop() {
   PIRSensor();
}

void PIRSensor() {
   if(digitalRead(pirPin) == HIGH) {
      if(lockLow) {
         PIRValue = 1;
         lockLow = false;
         Serial.println("Motion detected.");
         delay(50);
      }
      takeLowTime = true;
   }
   if(digitalRead(pirPin) == LOW) {
      if(takeLowTime){
         lowIn = millis();takeLowTime = false;
      }
      if(!lockLow && millis() - lowIn > pause) {
         PIRValue = 0;
         lockLow = true;
         Serial.println("Motion ended.");
         delay(50);
      }
   }
}

नोट करने के लिए कोड

PIR सेंसर में तीन टर्मिनल हैं - V cc , OUT और GND। सेंसर को निम्नानुसार कनेक्ट करें -

  • Arduino बोर्ड पर + V cc + 5v कनेक्ट करें ।
  • Arduino बोर्ड पर OUT को डिजिटल पिन 2 से कनेक्ट करें।
  • Arduino पर GND के साथ GND कनेक्ट करें।

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

एक बार सेंसर किसी भी गति का पता लगा लेता है, तो Arduino सीरियल पोर्ट के माध्यम से एक संदेश भेजेगा कि एक गति का पता चला है। यदि कोई नई गति है, तो जाँच करने के लिए PIR भावना प्रस्ताव निश्चित समय के लिए विलंब करेगा। यदि गति का पता नहीं चलता है, तो Arduino एक नया संदेश भेजते हुए कहेगा कि गति समाप्त हो गई है।

परिणाम

यदि गति का पता चला है और गति रुकने पर एक अन्य संदेश आपको अपने सीरियल पोर्ट पर एक संदेश दिखाई देगा।

HC-SR04 अल्ट्रासोनिक सेंसर सोनार का उपयोग किसी वस्तु की दूरी को निर्धारित करने के लिए करता है जैसे चमगादड़ करते हैं। यह 2 सेमी से 400 सेमी या 1 ”से 13 फीट तक के उपयोग में आसान पैकेज में उच्च सटीकता और स्थिर रीडिंग के साथ उत्कृष्ट गैर-संपर्क सीमा का पता लगाता है।

ऑपरेशन सूरज की रोशनी या काली सामग्री से प्रभावित नहीं होता है, हालांकि ध्वनिक रूप से, कपड़े जैसी नरम सामग्री का पता लगाना मुश्किल हो सकता है। यह अल्ट्रासोनिक ट्रांसमीटर और रिसीवर मॉड्यूल के साथ पूरा होता है।

तकनीकी निर्देश

  • बिजली की आपूर्ति - + 5 वी डीसी
  • मौन वर्तमान - <2mA
  • काम कर रहे वर्तमान - 15mA
  • प्रभावशाली कोण - <15 °
  • रेंजिंग दूरी - 2 सेमी - 400 सेमी / 1 ft - 13 फीट
  • संकल्प - 0.3 सेमी
  • मापने वाला कोण - 30 डिग्री

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × ब्रेडबोर्ड
  • 1 × अरुडिनो उनो आर 3
  • 1 × अल्ट्रासेन्ट सेंसर (HC-SR04)

प्रक्रिया

सर्किट आरेख का पालन करें और नीचे दी गई छवि में दिखाए अनुसार कनेक्शन बनाएं।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

Arduino कोड

const int pingPin = 7; // Trigger Pin of Ultrasonic Sensor
const int echoPin = 6; // Echo Pin of Ultrasonic Sensor

void setup() {
   Serial.begin(9600); // Starting Serial Terminal
}

void loop() {
   long duration, inches, cm;
   pinMode(pingPin, OUTPUT);
   digitalWrite(pingPin, LOW);
   delayMicroseconds(2);
   digitalWrite(pingPin, HIGH);
   delayMicroseconds(10);
   digitalWrite(pingPin, LOW);
   pinMode(echoPin, INPUT);
   duration = pulseIn(echoPin, HIGH);
   inches = microsecondsToInches(duration);
   cm = microsecondsToCentimeters(duration);
   Serial.print(inches);
   Serial.print("in, ");
   Serial.print(cm);
   Serial.print("cm");
   Serial.println();
   delay(100);
}

long microsecondsToInches(long microseconds) {
   return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds) {
   return microseconds / 29 / 2;
}

नोट करने के लिए कोड

अल्ट्रासोनिक सेंसर के चार टर्मिनल हैं - + 5 V, ट्रिगर, इको और GND निम्नानुसार हैं -

  • अपने Arduino बोर्ड पर + 5V पिन को + 5v से कनेक्ट करें।
  • अपने Arduino बोर्ड पर ट्रिगर को डिजिटल पिन 7 से कनेक्ट करें।
  • अपने Arduino बोर्ड पर इको को डिजिटल पिन 6 से कनेक्ट करें।
  • Arduino पर GND के साथ GND कनेक्ट करें।

हमारे कार्यक्रम में, हमने सीरियल पोर्ट के माध्यम से इंच और सेमी में सेंसर द्वारा मापा गया दूरी प्रदर्शित किया है।

परिणाम

आप Arduino सीरियल मॉनिटर पर इंच और सेमी में सेंसर द्वारा मापी गई दूरी देखेंगे।

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

पुल-डाउन रेसिस्टर

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

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

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

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × Arduino UNO बोर्ड
  • 1 × 330 ओम अवरोधक
  • 1 × 4.7 k ओम रोकनेवाला (नीचे खींचो)
  • 1 × एलईडी

प्रक्रिया

सर्किट आरेख का पालन करें और नीचे दी गई छवि में दिखाए अनुसार कनेक्शन बनाएं।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

Arduino कोड

// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 8; // the number of the pushbutton pin
const int ledPin = 2; // the number of the LED pin
// variables will change:
int buttonState = 0; // variable for reading the pushbutton status

void setup() {
   // initialize the LED pin as an output:
   pinMode(ledPin, OUTPUT);
   // initialize the pushbutton pin as an input:
   pinMode(buttonPin, INPUT);
}

void loop() {
   // read the state of the pushbutton value:
   buttonState = digitalRead(buttonPin);
   // check if the pushbutton is pressed.
   // if it is, the buttonState is HIGH:
   if (buttonState == HIGH) {
      // turn LED on:
      digitalWrite(ledPin, HIGH);
   } else {
      // turn LED off:
      digitalWrite(ledPin, LOW);
   }
}

नोट करने के लिए कोड

जब स्विच खुला होता है, (पुशबटन को दबाया नहीं जाता है), पुशबटन के दो टर्मिनलों के बीच कोई संबंध नहीं है, इसलिए पिन जमीन से जुड़ा हुआ है (पुल-डाउन रेसिस्टर के माध्यम से) और हम एक LOW पढ़ते हैं। जब स्विच बंद हो जाता है (पुशबटन को दबाया जाता है), यह अपने दो टर्मिनलों के बीच एक संबंध बनाता है, पिन को 5 वोल्ट से जोड़ता है, ताकि हम एक उच्च पढ़ें।

परिणाम

LED को तब चालू किया जाता है जब पुशबटन को दबाया जाता है और जब इसे छोड़ा जाता है तो इसे बंद कर दिया जाता है।

इस अध्याय में, हम Arduino Board (UNO) के साथ विभिन्न प्रकार के मोटर्स को इंटरफेस करेंगे और आपको दिखाएंगे कि मोटर को कैसे कनेक्ट करें और इसे अपने बोर्ड से ड्राइव करें।

तीन अलग-अलग प्रकार की मोटरें हैं -

  • डीसी यंत्र
  • सर्वो मोटर
  • स्टेपर मोटर

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

Warning- सीधे Arduino बोर्ड पिन से मोटर न चलाएं। इससे बोर्ड को नुकसान हो सकता है। ड्राइवर सर्किट या आईसी का उपयोग करें।

हम इस अध्याय को तीन भागों में विभाजित करेंगे -

  • बस अपनी मोटर स्पिन करें
  • मोटर की गति को नियंत्रित करें
  • डीसी मोटर के स्पिन की दिशा को नियंत्रित करें

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1x Arduino UNO बोर्ड
  • 1x PN2222 ट्रांजिस्टर
  • 1x छोटा 6V डीसी मोटर
  • 1x 1N4001 डायोड
  • 1x 270। रेसिस्टर

प्रक्रिया

सर्किट आरेख का पालन करें और नीचे दी गई छवि में दिखाए अनुसार कनेक्शन बनाएं।

एहतियात

संबंध बनाते समय निम्नलिखित सावधानियां बरतें।

  • First, make sure that the transistor is connected in the right way. The flat side of the transistor should face the Arduino board as shown in the arrangement.

  • Second, the striped end of the diode should be towards the +5V power line according to the arrangement shown in the image.

Spin ControlArduino Code

int motorPin = 3;

void setup() {

}

void loop() {
   digitalWrite(motorPin, HIGH);
}

Code to Note

The transistor acts like a switch, controlling the power to the motor. Arduino pin 3 is used to turn the transistor on and off and is given the name 'motorPin' in the sketch.

Result

Motor will spin in full speed when the Arduino pin number 3 goes high.

Motor Speed Control

Following is the schematic diagram of a DC motor, connected to the Arduino board.

Arduino Code

int motorPin = 9;

void setup() {
   pinMode(motorPin, OUTPUT);
   Serial.begin(9600);
   while (! Serial);
   Serial.println("Speed 0 to 255");
}

void loop() {
   if (Serial.available()) {
      int speed = Serial.parseInt();
      if (speed >= 0 && speed <= 255) {
         analogWrite(motorPin, speed);
      }
   }
}

Code to Note

The transistor acts like a switch, controlling the power of the motor. Arduino pin 3 is used to turn the transistor on and off and is given the name 'motorPin' in the sketch.

When the program starts, it prompts you to give the values to control the speed of the motor. You need to enter a value between 0 and 255 in the Serial Monitor.

In the 'loop' function, the command 'Serial.parseInt' is used to read the number entered as text in the Serial Monitor and convert it into an 'int'. You can type any number here. The 'if' statement in the next line simply does an analog write with this number, if the number is between 0 and 255.

Result

The DC motor will spin with different speeds according to the value (0 to 250) received via the serial port.

Spin Direction Control

To control the direction of the spin of DC motor, without interchanging the leads, you can use a circuit called an H-Bridge. An H-bridge is an electronic circuit that can drive the motor in both directions. H-bridges are used in many different applications. One of the most common application is to control motors in robots. It is called an H-bridge because it uses four transistors connected in such a way that the schematic diagram looks like an "H."

We will be using the L298 H-Bridge IC here. The L298 can control the speed and direction of DC motors and stepper motors, and can control two motors simultaneously. Its current rating is 2A for each motor. At these currents, however, you will need to use heat sinks.

Components Required

You will need the following components −

  • 1 × L298 bridge IC
  • 1 × DC motor
  • 1 × Arduino UNO
  • 1 × breadboard
  • 10 × jumper wires

Procedure

Following is the schematic diagram of the DC motor interface to Arduino Uno board.

The above diagram shows how to connect the L298 IC to control two motors. There are three input pins for each motor, Input1 (IN1), Input2 (IN2), and Enable1 (EN1) for Motor1 and Input3, Input4, and Enable2 for Motor2.

Since we will be controlling only one motor in this example, we will connect the Arduino to IN1 (pin 5), IN2 (pin 7), and Enable1 (pin 6) of the L298 IC. Pins 5 and 7 are digital, i.e. ON or OFF inputs, while pin 6 needs a pulse-width modulated (PWM) signal to control the motor speed.

The following table shows which direction the motor will turn based on the digital values of IN1 and IN2.

IN1 IN2 Motor Behavior
BRAKE
1 FORWARD
1 BACKWARD
1 1 BRAKE

Pin IN1 of the IC L298 is connected to pin 8 of Arduino while IN2 is connected to pin 9. These two digital pins of Arduino control the direction of the motor. The EN A pin of IC is connected to the PWM pin 2 of Arduino. This will control the speed of the motor.

To set the values of Arduino pins 8 and 9, we have used the digitalWrite() function, and to set the value of pin 2, we have to use the analogWrite() function.

Connection Steps

  • Connect 5V and the ground of the IC to 5V and the ground of Arduino, respectively.
  • Connect the motor to pins 2 and 3 of the IC.
  • Connect IN1 of the IC to pin 8 of Arduino.
  • Connect IN2 of the IC to pin 9 of Arduino.
  • Connect EN1 of IC to pin 2 of Arduino.
  • Connect SENS A pin of IC to the ground.
  • Connect Arduino using Arduino USB cable and upload the program to Arduino using Arduino IDE software.
  • Provide power to Arduino board using power supply, battery, or USB cable.

Arduino Code

const int pwm = 2 ; //initializing pin 2 as pwm
const int in_1 = 8 ;
const int in_2 = 9 ;
//For providing logic to L298 IC to choose the direction of the DC motor

void setup() {
   pinMode(pwm,OUTPUT) ; //we have to set PWM pin as output
   pinMode(in_1,OUTPUT) ; //Logic pins are also set as output
   pinMode(in_2,OUTPUT) ;
}

void loop() {
   //For Clock wise motion , in_1 = High , in_2 = Low
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,LOW) ;
   analogWrite(pwm,255) ;
   /* setting pwm of the motor to 255 we can change the speed of rotation
   by changing pwm input but we are only using arduino so we are using highest
   value to driver the motor */
   //Clockwise for 3 secs
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
   //For Anti Clock-wise motion - IN_1 = LOW , IN_2 = HIGH
   digitalWrite(in_1,LOW) ;
   digitalWrite(in_2,HIGH) ;
   delay(3000) ;
   //For brake
   digitalWrite(in_1,HIGH) ;
   digitalWrite(in_2,HIGH) ;
   delay(1000) ;
}

Result

The motor will run first in the clockwise (CW) direction for 3 seconds and then counter-clockwise (CCW) for 3 seconds.

A Servo Motor is a small device that has an output shaft. This shaft can be positioned to specific angular positions by sending the servo a coded signal. As long as the coded signal exists on the input line, the servo will maintain the angular position of the shaft. If the coded signal changes, the angular position of the shaft changes. In practice, servos are used in radio-controlled airplanes to position control surfaces like the elevators and rudders. They are also used in radio-controlled cars, puppets, and of course, robots.

Servos are extremely useful in robotics. The motors are small, have built-in control circuitry, and are extremely powerful for their size. A standard servo such as the Futaba S-148 has 42 oz/inches of torque, which is strong for its size. It also draws power proportional to the mechanical load. A lightly loaded servo, therefore, does not consume much energy.

The guts of a servo motor is shown in the following picture. You can see the control circuitry, the motor, a set of gears, and the case. You can also see the 3 wires that connect to the outside world. One is for power (+5volts), ground, and the white wire is the control wire.

एक इमदादी मोटर का कार्य करना

सर्वो मोटर में कुछ नियंत्रण सर्किट होते हैं और आउटपुट शाफ्ट से जुड़ा एक पोटेंशियोमीटर (एक चर अवरोधक, उर्फ ​​पॉट) होता है। ऊपर की तस्वीर में, सर्किट बोर्ड के दाईं ओर पॉट देखा जा सकता है। यह पॉट नियंत्रण सर्किटरी को इमदादी मोटर के वर्तमान कोण की निगरानी करने की अनुमति देता है।

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

मोटर पर लागू होने वाली शक्ति उस दूरी के लिए आनुपातिक है जो उसे यात्रा करने के लिए आवश्यक है। इसलिए, यदि शाफ्ट को एक बड़ी दूरी को चालू करने की आवश्यकता है, तो मोटर पूरी गति से चलेगी। यदि इसे केवल एक छोटी राशि चालू करने की आवश्यकता है, तो मोटर धीमी गति से चलेगी। यह कहा जाता हैproportional control।

आप किस तरह से किस मोड़ पर सर्वो को बदलना चाहते हैं?

नियंत्रण तार का उपयोग कोण को संप्रेषित करने के लिए किया जाता है। कोण एक पल्स की अवधि से निर्धारित होता है जो नियंत्रण तार पर लागू होता है। यह कहा जाता हैPulse Coded Modulation। सर्वो को हर 20 मिलीसेकंड (.02 सेकंड) पर एक नाड़ी देखने की उम्मीद है। नाड़ी की लंबाई निर्धारित करेगी कि मोटर कितनी दूर जाती है। एक 1.5 मिलीसेकंड पल्स, उदाहरण के लिए, मोटर को 90 डिग्री की स्थिति में बदल देगा (जिसे अक्सर तटस्थ स्थिति कहा जाता है)। यदि पल्स 1.5 मिलीसेकंड से कम है, तो मोटर शाफ्ट को 0 डिग्री के करीब बदल देगा। यदि पल्स 1.5 मिलीसेकंड से अधिक है, तो शाफ्ट 180 डिग्री के करीब हो जाता है।

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × Arduino UNO बोर्ड
  • 1 × सर्वो मोटर
  • 1 × ULN2003 ड्राइविंग आईसी
  • 1 × 10 KΩ रोकनेवाला

प्रक्रिया

सर्किट आरेख का पालन करें और नीचे दी गई छवि में दिखाए अनुसार कनेक्शन बनाएं।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

Arduino कोड

/* Controlling a servo position using a potentiometer (variable resistor) */

#include <Servo.h>
   Servo myservo; // create servo object to control a servo
   int potpin = 0; // analog pin used to connect the potentiometer
   int val; // variable to read the value from the analog pin

void setup() {
   myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
   val = analogRead(potpin);
   // reads the value of the potentiometer (value between 0 and 1023)
   val = map(val, 0, 1023, 0, 180);
   // scale it to use it with the servo (value between 0 and 180)
   myservo.write(val); // sets the servo position according to the scaled value
   delay(15);
}

नोट करने के लिए कोड

सर्वो मोटर्स के तीन टर्मिनल हैं - पावर, ग्राउंड और सिग्नल। बिजली का तार आम तौर पर लाल होता है, और इसे Arduino पर 5V पिन से जोड़ा जाना चाहिए। जमीन का तार आम तौर पर काला या भूरा होता है और इसे ULN2003 IC (10 -16) के एक टर्मिनल से जुड़ा होना चाहिए। अपने Arduino बोर्ड को नुकसान से बचाने के लिए, आपको ऐसा करने के लिए कुछ ड्राइवर IC की आवश्यकता होगी। यहां हमने सर्वो मोटर को चलाने के लिए ULN2003 IC का उपयोग किया है। सिग्नल पिन आमतौर पर पीला या नारंगी होता है और इसे Arduino पिन नंबर 9 से जोड़ा जाना चाहिए।

पोटेंशियोमीटर को जोड़ना

एक वोल्टेज डिवाइडर / संभावित विभक्त एक श्रृंखला सर्किट में प्रतिरोधक होते हैं जो आउटपुट वोल्टेज को लागू इनपुट वोल्टेज के एक विशेष अनुपात में मापते हैं। निम्नलिखित सर्किट आरेख है -

$$ V_ {आउट} = (V_ {in} \ _ R_ {2}) / (R_ {1} + R_ {2}) $$

वी बाहर उत्पादन संभावित है, जो लागू इनपुट वोल्टेज पर निर्भर करता है (वी है में ) और प्रतिरोधों (आर 1 और आर 2 श्रृंखला में)। इसका मतलब है कि R 1 से बहने वाला प्रवाह भी R 2 के माध्यम से विभाजित किए बिना बहेगा । उपरोक्त समीकरण में, R 2 के मान में परिवर्तन होता है, V आउट इनपुट इनपुट के संबंध में स्केल करता है, V में ।

आमतौर पर, एक पोटेंशियोमीटर एक संभावित विभक्त होता है, जो चर अवरोध के मूल्य के आधार पर सर्किट के आउटपुट वोल्टेज को स्केल कर सकता है, जिसे घुंडी का उपयोग करके स्केल किया जाता है। इसके तीन पिन हैं: जीएनडी, सिग्नल और +5 वी जैसा कि नीचे चित्र में दिखाया गया है -

परिणाम

पॉट की एनओपी स्थिति को बदलकर, सर्वो मोटर अपने कोण को बदल देगा।

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

इसलिए स्टेपर मोटर्स को 12, 24, 72, 144, 180 और 200 की क्रांति के साथ निर्मित किया जाता है, जिसके परिणामस्वरूप 30, 15, 5, 2.5, 2 और 1.8 डिग्री प्रति चरण के कोण हैं। स्टेपर मोटर को प्रतिक्रिया के साथ या उसके बिना नियंत्रित किया जा सकता है।

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

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

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

कैसे एक Stepper मोटर काम करता है?

एक नियमित डीसी मोटर केवल दिशा में घूमती है जबकि एक स्टेपर मोटर सटीक वेतन वृद्धि में स्पिन कर सकती है।

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

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

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × Arduino UNO बोर्ड
  • 1 × छोटे द्विध्रुवी स्टेपर मोटर जैसा कि नीचे दी गई छवि में दिखाया गया है
  • 1 × LM298 ड्राइविंग आईसी

प्रक्रिया

सर्किट आरेख का पालन करें और नीचे दी गई छवि में दिखाए अनुसार कनेक्शन बनाएं।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

Arduino कोड

/* Stepper Motor Control */

#include <Stepper.h>
const int stepsPerRevolution = 90;
// change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

void setup() {
   // set the speed at 60 rpm:
   myStepper.setSpeed(5);
   // initialize the serial port:
   Serial.begin(9600);
}

void loop() {
   // step one revolution in one direction:
   Serial.println("clockwise");
   myStepper.step(stepsPerRevolution);
   delay(500);
   // step one revolution in the other direction:
   Serial.println("counterclockwise");
   myStepper.step(-stepsPerRevolution);
   delay(500);
}

नोट करने के लिए कोड

यह कार्यक्रम एकध्रुवीय या द्विध्रुवीय स्टेपर मोटर चलाता है। मोटर Arduino के डिजिटल पिन 8 - 11 से जुड़ा हुआ है।

परिणाम

मोटर एक दिशा में एक क्रांति लेगी, फिर दूसरी दिशा में एक क्रांति।

इस अध्याय में, हम Arduino Tone लाइब्रेरी का उपयोग करेंगे। यह एक अरुडिनो लाइब्रेरी के अलावा कुछ भी नहीं है, जो किसी भी Arduino पिन पर एक निर्दिष्ट आवृत्ति (और 50% कर्तव्य चक्र) के वर्ग-लहर का उत्पादन करता है। एक अवधि वैकल्पिक रूप से निर्दिष्ट की जा सकती है, अन्यथा जब तक स्टॉप () फ़ंक्शन कहा जाता है, तब तक लहर जारी रहती है। टोन को बजाने के लिए पिन को पीजो बजर या स्पीकर से जोड़ा जा सकता है।

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

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × 8-ओम स्पीकर
  • 1 × 1k रोकनेवाला
  • 1 × Arduino UNO बोर्ड

प्रक्रिया

सर्किट आरेख का पालन करें और नीचे दी गई छवि में दिखाए अनुसार कनेक्शन बनाएं।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

पिच.ह फ़ाइल बनाने के लिए, या तो सीरियल मॉनिटर आइकन के ठीक नीचे बटन पर क्लिक करें और "नया टैब" चुनें, या Ctrl + Shift + N का उपयोग करें।

फिर निम्नलिखित कोड पेस्ट करें -

/*************************************************
* Public Constants
*************************************************/

#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978

ऊपर दिए गए कोड को इस तरह सेव करें pitches.h

Arduino कोड

#include "pitches.h"
// notes in the melody:
int melody[] = {
NOTE_C4, NOTE_G3,NOTE_G3, NOTE_GS3, NOTE_G3,0, NOTE_B3, NOTE_C4};
// note durations: 4 = quarter note, 8 = eighth note, etc.:

int noteDurations[] = {
   4, 8, 8, 4,4,4,4,4 
};

void setup() {
   // iterate over the notes of the melody:
   for (int thisNote = 0; thisNote < 8; thisNote++) {
      // to calculate the note duration, take one second
      // divided by the note type.
      //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
      int noteDuration = 1000/noteDurations[thisNote];
      tone(8, melody[thisNote],noteDuration);
      //pause for the note's duration plus 30 ms:
      delay(noteDuration +30);
   }
}

void loop() {
   // no need to repeat the melody.
}

नोट करने के लिए कोड

कोड एक अतिरिक्त फ़ाइल का उपयोग करता है। इस फ़ाइल में विशिष्ट नोट्स के लिए सभी पिच मान हैं। उदाहरण के लिए, NOTE_C4 मध्यम C. NOTE_FS4 एफ तेज है, और आगे है। यह नोट तालिका मूल रूप से ब्रेट हैगमैन द्वारा लिखी गई थी, जिसके कार्य पर स्वर () कमांड आधारित था। जब भी आप संगीत नोट्स बनाना चाहते हैं तो आपको यह उपयोगी लग सकता है।

परिणाम

आप पिचों में सहेजे हुए संगीत नोट सुनेंगे। फ़ाइल।

वायरलेस ट्रांसमीटर और रिसीवर मॉड्यूल 315 मेगाहर्ट्ज पर काम करते हैं। वे आसानी से ब्रेडबोर्ड में फिट हो सकते हैं और एक बहुत ही सरल वायरलेस डेटा लिंक बनाने के लिए माइक्रोकंट्रोलर्स के साथ अच्छी तरह से काम कर सकते हैं। ट्रांसमीटर और रिसीवर की एक जोड़ी के साथ, मॉड्यूल केवल डेटा को एक-तरफ़ा संचार करने का काम करेगा, हालांकि, ट्रांसमीटर / रिसीवर जोड़ी के रूप में कार्य करने के लिए आपको दो जोड़े (विभिन्न आवृत्तियों के) की आवश्यकता होगी।

Note- ये मॉड्यूल अंधाधुंध हैं और उचित मात्रा में शोर प्राप्त करते हैं। ट्रांसमीटर और रिसीवर दोनों सामान्य आवृत्तियों पर काम करते हैं और आईडी नहीं रखते हैं।

रिसीवर मॉड्यूल विनिर्देशों

  • उत्पाद मॉडल - एमएक्स -05 वी
  • ऑपरेटिंग वोल्टेज - DC5V
  • मौन वर्तमान - 4mA
  • आवृत्ति प्राप्त करना - 315Mhz
  • रिसीवर संवेदनशीलता - -105DB
  • आकार - 30 * 14 * 7 मिमी

ट्रांसमीटर मॉड्यूल विनिर्देशों

  • उत्पाद मॉडल - एमएक्स-एफएस -03 वी
  • लॉन्च दूरी - 20-200 मीटर (विभिन्न वोल्टेज, विभिन्न परिणाम)
  • ऑपरेटिंग वोल्टेज - 3.5-12V
  • आयाम - 19 * 19 मिमी
  • ऑपरेटिंग मोड - एएम
  • अंतरण दर - 4KB / S
  • संचारण शक्ति - 10mW
  • संचारण आवृत्ति - 315Mhz
  • एक बाहरी एंटीना - 25 सेमी साधारण मल्टी-कोर या सिंगल-कोर लाइन
  • बाएं से दाएं → दाएं - (डेटा; वी सीसी ; जीएनडी)

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 2 × Arduino UNO बोर्ड
  • 1 × आरएफ लिंक ट्रांसमीटर
  • 1 × आरएफ लिंक रिसीवर

प्रक्रिया

सर्किट आरेख का पालन करें और नीचे दी गई छवि में दिखाए अनुसार कनेक्शन बनाएं।

स्केच

अपने कंप्यूटर पर Arduino IDE सॉफ्टवेयर खोलें। Arduino भाषा में कोडिंग आपके सर्किट को नियंत्रित करेगा। New पर क्लिक करके एक नया स्केच फाइल खोलें।

Note- आपको अपने Arduino लाइब्रेरी फ़ाइल में कीपैड लाइब्रेरी को शामिल करना होगा। नीचे दिए गए स्क्रीनशॉट में हाइलाइट किए गए पुस्तकालयों के फ़ोल्डर में VirtualWire.lib फ़ाइल को कॉपी और पेस्ट करें।

ट्रांसमीटर के लिए Arduino कोड

//simple Tx on pin D12
#include <VirtualWire.h>
char *controller;

void setup() {
   pinMode(13,OUTPUT);
   vw_set_ptt_inverted(true);
   vw_set_tx_pin(12);
   vw_setup(4000);// speed of data transfer Kbps
}

void loop() {
   controller="1" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,1);
   delay(2000);
   controller="0" ;
   vw_send((uint8_t *)controller, strlen(controller));
   vw_wait_tx(); // Wait until the whole message is gone
   digitalWrite(13,0);
   delay(2000);
}

नोट करने के लिए कोड

यह एक सरल कोड है। सबसे पहले, यह चरित्र '1' भेजेगा और दो सेकंड के बाद यह चरित्र '0' और इतने पर भेज देगा।

रिसीवर के लिए Arduino कोड

//simple Rx on pin D12
#include <VirtualWire.h>

void setup() {
   vw_set_ptt_inverted(true); // Required for DR3100
   vw_set_rx_pin(12);
   vw_setup(4000); // Bits per sec
   pinMode(5, OUTPUT);
   vw_rx_start(); // Start the receiver PLL running
}

void loop() {
   uint8_t buf[VW_MAX_MESSAGE_LEN];
   uint8_t buflen = VW_MAX_MESSAGE_LEN;
   if (vw_get_message(buf, &buflen)) // Non-blocking {
      if(buf[0]=='1') {
         digitalWrite(5,1);
      }
      if(buf[0]=='0') {
         digitalWrite(5,0);
      }
   }
}

नोट करने के लिए कोड

Arduino बोर्ड पर पिन नंबर 5 से जुड़ी एलईडी चालू है जब चरित्र '1' प्राप्त होता है और वर्ण '0' प्राप्त होने पर बंद हो जाता है।

टेक्सास इंस्ट्रूमेंट्स से CC3000 वाईफाई मॉड्यूल एक छोटा सा सिल्वर पैकेज है, जो अंत में आपके Arino प्रोजेक्ट्स के लिए आसान-से-उपयोग, सस्ती वाईफाई कार्यक्षमता लाता है।

यह संचार के लिए SPI का उपयोग करता है (UART नहीं!) ताकि आप डेटा को जितना चाहें उतनी तेजी से धक्का दे सकें या जितना चाहें उतना धीमा कर सकें। इसमें IRQ पिन के साथ एक उचित व्यवधान प्रणाली है ताकि आप अतुल्यकालिक कनेक्शन रख सकें। यह 802.11 बी / जी, ओपन / डब्ल्यूईपी / डब्ल्यूपीए / डब्ल्यूपीए 2 सुरक्षा, टीकेआईपी और एईएस का समर्थन करता है। एक "BSD सॉकेट" इंटरफ़ेस के साथ निर्मित टीसीपी / आईपी स्टैक क्लाइंट और सर्वर मोड दोनों में टीसीपी और यूडीपी का समर्थन करता है।

अवयव आवश्यक

आपको निम्नलिखित घटकों की आवश्यकता होगी -

  • 1 × Arduino Uno
  • 1 × प्रवेश CC3000 ब्रेकआउट बोर्ड
  • 1 × 5V रिले
  • 1 × आयताकार डायोड
  • 1 × एलईडी
  • 1 × 220 ओम अवरोधक
  • 1 × ब्रेडबोर्ड और कुछ जम्पर तार

इस परियोजना के लिए, आपको बस सामान्य Arduino IDE, Adafruit की CC3000 लाइब्रेरी और CC3000 CNS लाइब्रेरी की आवश्यकता है। हम वाईफाई के माध्यम से रिले को कमांड भेजने के लिए aREST लाइब्रेरी का उपयोग करने जा रहे हैं।

प्रक्रिया

सर्किट आरेख का पालन करें और नीचे दी गई छवि में दिखाए अनुसार कनेक्शन बनाएं।

इस परियोजना के लिए हार्डवेयर विन्यास बहुत आसान है।

  • Arduino बोर्ड के नंबर 3 को पिन करने के लिए CC3000 बोर्ड के IRQ पिन को कनेक्ट करें।
  • 5 पिन करने के लिए VBAT, और 10 पिन करने के लिए CS।
  • Arduino बोर्ड में SPI पिन को कनेक्ट करें: MOSI, MISO, और CLK को क्रमशः 11, 12 और 13 पिन से पिन करें।
  • वी में Arduino 5V, और GND GND से जुड़ा है।

अब हम रिले को कनेक्ट करते हैं।

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

  • सबसे पहले, Arduino बोर्ड के पिन नंबर 8 को कॉइल के एक पिन से कनेक्ट करें।
  • दूसरे पिन को Arduino बोर्ड की जमीन से कनेक्ट करें।

आपको अपने सर्किट को बचाने के लिए कॉइल के पिन के ऊपर रेक्टिफायर डायोड (ग्राउंड पिन से जुड़ा हुआ एनोड) रखना होता है, जब रिले स्विच कर रहा होता है।

  • रिले के स्विच के सामान्य पिन को Arduino बोर्ड के + 5V से कनेक्ट करें।

  • अंत में, स्विच के दूसरे पिन में से एक को कनेक्ट करें (आमतौर पर, वह जो रिले के बंद होने पर कनेक्ट नहीं होता है) 220 ओम अवरोधक के साथ श्रृंखला में एलईडी के लिए, और एलईडी के दूसरी तरफ को Arduino के जमीन से कनेक्ट करें मंडल।

व्यक्तिगत घटकों का परीक्षण

आप निम्न स्केच के साथ रिले का परीक्षण कर सकते हैं -

const int relay_pin = 8; // Relay pin

void setup() {
   Serial.begin(9600);
   pinMode(relay_pin,OUTPUT);
}

void loop() {
   // Activate relay
   digitalWrite(relay_pin, HIGH);
   // Wait for 1 second
   delay(1000);
   // Deactivate relay
   digitalWrite(relay_pin, LOW);
   // Wait for 1 second
   delay(1000);
}

नोट करने के लिए कोड

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

वाईफाई कनेक्टिविटी जोड़ना

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

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

संहिता के महत्वपूर्ण भाग

#include <Adafruit_CC3000.h>
#include <SPI.h>
#include <CC3000_MDNS.h>
#include <Ethernet.h>
#include <aREST.h>

आपको उस कोड के अंदर परिभाषित करने की आवश्यकता है जो आपके कॉन्फ़िगरेशन के लिए विशिष्ट है, अर्थात वाई-फाई नाम और पासवर्ड, और टीसीपी संचार के लिए पोर्ट (हमने यहां 80 का उपयोग किया है)।

// WiFi network (change with your settings!)
   #define WLAN_SSID "yourNetwork" // cannot be longer than 32 characters!
   #define WLAN_PASS "yourPassword"
   #define WLAN_SECURITY WLAN_SEC_WPA2 // This can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, 
   // WLAN_SEC_WPA or WLAN_SEC_WPA2

// The port to listen for incoming TCP connections
   #define LISTEN_PORT 80

फिर हम CC3000 इंस्टेंस, सर्वर और ऐरेस्ट उदाहरण बना सकते हैं -

// Server instance
   Adafruit_CC3000_Server restServer(LISTEN_PORT); // DNS responder instance
   MDNSResponder mdns; // Create aREST instance
   aREST rest = aREST();

स्केच के सेटअप () भाग में, हम अब CC3000 चिप को नेटवर्क से जोड़ सकते हैं -

cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY);

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

यह निम्नलिखित कोड के साथ किया जाता है -

if (!mdns.begin("arduino", cc3000)) {
   while(1);
}

हमें आने वाले कनेक्शनों के लिए भी सुनना होगा।

restServer.begin();

अगला, हम स्केच के लूप () फ़ंक्शन को कोड करेंगे जो लगातार निष्पादित होंगे। हमें सबसे पहले mDNS सर्वर को अपडेट करना होगा।

mdns.update();

Arduino बोर्ड पर चलने वाला सर्वर आने वाले कनेक्शन की प्रतीक्षा करेगा और अनुरोधों को संभाल लेगा।

Adafruit_CC3000_ClientRef client = restServer.available();
rest.handle(client);

वाईफाई के माध्यम से परियोजनाओं का परीक्षण करना अब काफी आसान है। सुनिश्चित करें कि आपने अपने स्वयं के वाईफाई नाम और पासवर्ड के साथ स्केच को अपडेट किया है, और स्केच को अपने Arduino बोर्ड पर अपलोड करें। अपने Arduino IDE सीरियल मॉनिटर को खोलें, और अपने बोर्ड के आईपी पते की तलाश करें।

यहाँ बाकी के लिए मान लें कि यह 192.168.1.103 की तरह है।

फिर, बस अपने पसंदीदा वेब ब्राउज़र पर जाएं, और टाइप करें -

192.168.1.103/digital/8/1

आपको यह देखना चाहिए कि आपका रिले स्वतः चालू हो जाता है।

रिले इंटरफ़ेस का निर्माण

अब हम प्रोजेक्ट के इंटरफ़ेस को कोड करेंगे। यहां दो भाग होंगे: इंटरफ़ेस पर क्लिक को संभालने के लिए एक HTML फ़ाइल जिसमें इंटरफ़ेस और क्लाइंट-साइड जावास्क्रिप्ट फ़ाइल है। यहाँ इंटरफ़ेस पर आधारित हैaREST.js परियोजना, जो आपके कंप्यूटर से वाईफाई उपकरणों को आसानी से नियंत्रित करने के लिए बनाई गई थी।

आइए हम पहले HTML फाइल देखते हैं, जिसे interface.html कहा जाता है। पहले भाग में इंटरफ़ेस के लिए सभी आवश्यक लाइब्रेरीज़ आयात करना शामिल है -

<head>
   <meta charset = utf-8 />
   <title> Relay Control </title>
   <link rel = "stylesheet" type = "text/css" 
      href = "https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
   <link rel="stylesheet" type = "text/css" href = "style.css">
   <script type = "text/javascript" 
      src = "https://code.jquery.com/jquery-2.1.4.min.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/Foliotek/AjaxQ/master/ajaxq.js"></script>
   <script type = "text/javascript" 
      src = "https://cdn.rawgit.com/marcoschwartz/aREST.js/master/aREST.js"></script>
   <script type = "text/javascript" 
      src = "script.js"></script>
</head>

फिर, हम इंटरफ़ेस के अंदर दो बटन को परिभाषित करते हैं, एक रिले को चालू करने के लिए, और दूसरा इसे फिर से बंद करने के लिए।

<div class = 'container'>
   <h1>Relay Control</h1>
   <div class = 'row'>
      <div class = "col-md-1">Relay</div>
      <div class = "col-md-2">
         <button id = 'on' class = 'btn btn-block btn-success'>On</button>
      </div>
      <div class = "col-md-2">
         <button id = 'off' class = 'btn btn-block btn-danger'>On</button>
      </div>
   </div>
</div>

अब, हमें बटन पर क्लिक को संभालने के लिए एक क्लाइंट-साइड जावास्क्रिप्ट फ़ाइल की भी आवश्यकता है। हम एक डिवाइस भी बनाएंगे जिसे हम अपने Arduino डिवाइस के mDNS नाम से लिंक करेंगे। यदि आपने इसे Arduino कोड में बदल दिया है, तो आपको इसे यहाँ भी संशोधित करना होगा।

// Create device
var device = new Device("arduino.local");
// Button

$('#on').click(function() {
   device.digitalWrite(8, 1);
});

$('#off').click(function() {
   device.digitalWrite(8, 0);
});

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

वेब इंटरफ़ेस पर एक बटन क्लिक करने की कोशिश करें; यह लगभग तुरंत रिले की स्थिति को बदलना चाहिए।

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

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved