शिफ्ट रजिस्टर. डिस्प्ले डिवाइस में शिफ्ट रजिस्टर का उपयोग करना शिफ्ट रजिस्टर का उपयोग करना

कभी-कभी आपको बहुत सारे आउटपुट पोर्ट की आवश्यकता होती है। खासकर अगर हम एलईडी के साथ कुछ करना चाहते हैं। कुछ फैंसी माला. क्या करें? इस मामले को लीजिए Atmega128अपने पचास निष्कर्षों के साथ? अत्यधिक - लैमर्स के लिए। पोर्ट विस्तारक के साथ i2 स्थापित करें? महँगा। प्रमुखों के लिए. यहां, अच्छा पुराना अलग तर्क सदियों पुरानी गहराइयों से बचाव के लिए आता है। इस बार, एक पैनी शिफ्ट रजिस्टर हमारी मदद करेगा। उदाहरण के लिए, मैं लेता हूँ, 74एचसी164उर्फ, एक अविनाशी पत्थर के मामले में सोवियत कचरा माइक्रोक्रिस्केट के प्रेमियों के लिए, हमारा KM555IR8.

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

रजिस्टर भरना सरल है:
1) उठाओ और पकड़ो रीसेटपहले में
2) हम पहला (सबसे महत्वपूर्ण) बिट जारी करते हैं डेटा.
3) इसे 0 तक कम करें और क्लॉक आउटपुट को 1 तक बढ़ाएँ। बढ़ते किनारे पर, रजिस्टर में प्रवेश किया जाता है और पूरी श्रृंखला को एक कदम से स्थानांतरित किया जाता है।
4) दूसरे बिंदु से तब तक दोहराएँ जब तक कि सभी बिट्स बाहर न आ जाएँ।

और रीसेट करने के लिए, बस इसे छोड़ दें रीसेटकुछ माइक्रोसेकंड के लिए शून्य पर।
यह आसान है :)

ZY
रजिस्टर इनपुट पर एक सर्कल का मतलब है कि इनपुट उलटा है। वे। शून्य दिया - यह काम कर गया
इनपुट पर त्रिकोण दिखाता है कि कौन सा किनारा ट्रिगर होगा। यह याद रखना आसान है: _/ \_ एक आवेग की तरह है। और त्रिभुज, एक तीर की तरह, वांछित मोर्चे की ओर इशारा करता है। ->_/ \_ अग्रणी (बढ़ता किनारा) और _/ \_<- задний (нисходящий фронт)

शिफ्ट रजिस्टर या शिफ्ट रजिस्टर फ्लिप-फ्लॉप की एक श्रृंखला से जुड़ी श्रृंखला है।

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

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

आरेखों में, आरजी अक्षर रजिस्टर प्रतीक के रूप में कार्य करते हैं। शिफ्ट रजिस्टरों के लिए, शिफ्ट दिशा भी निर्दिष्ट है:

· → दाएँ (मुख्य मोड जो सभी शिफ्ट रजिस्टरों में होता है);

· ← बाएँ (केवल कुछ प्रतिवर्ती शिफ्ट रजिस्टरों में यह मोड है);

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

शिफ्ट की दिशा शिफ्ट रजिस्टरों की आंतरिक संरचना (चित्र 4.14) और फ्लिप-फ्लॉप की श्रृंखला के साथ क्रमिक रूप से संकेतों के पुनर्लेखन द्वारा परिलक्षित होती है। इस मामले में, फ्लिप-फ्लॉप, काफी स्वाभाविक रूप से, बाएं से दाएं क्रमांकित होते हैं, उदाहरण के लिए, 8-बिट रजिस्टरों के लिए 0 से 7 (या 1 से 8 तक)। परिणामस्वरूप, किसी रजिस्टर द्वारा जानकारी को दाईं ओर स्थानांतरित करना उच्च संख्या वाले बिट्स की ओर एक बदलाव है, और रजिस्टर द्वारा जानकारी को बाईं ओर स्थानांतरित करना कम संख्या वाले बिट्स की ओर एक बदलाव है।

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

शिफ्ट रजिस्टर भंडारण और रूपांतरण कार्य कर सकते हैं।

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

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

शिफ्ट रजिस्टर डिजिटल रूप में दर्शाए गए सिग्नल के लिए विलंब तत्व के रूप में भी काम कर सकते हैं: अनुक्रमिक रिसेप्शन (इनपुट) और आउटपुट वाले रजिस्टर कंप्यूटर समय के एम+1 क्लॉक चक्र (एम+1 रजिस्टर बिट्स की संख्या है) द्वारा सूचना के प्रसारण में देरी करते हैं। .

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

यह ध्यान दिया जाना चाहिए कि सभी शिफ्ट रजिस्टर दो-चरण फ्लिप-फ्लॉप के आधार पर बनाए जाते हैं या घड़ी पल्स के किनारे से सिंक्रनाइज़ होते हैं।

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

स्टोरेज रजिस्टरों की तरह शिफ्ट रजिस्टरों की चौड़ाई, उनमें शामिल फ्लिप-फ्लॉप की संख्या से निर्धारित होती है।

आइए चित्र में दिखाए गए सर्किट के उदाहरण का उपयोग करके शिफ्ट रजिस्टर के संचालन पर विचार करें। चित्र.4.15.

यह माना जा सकता है कि शुरुआत में सभी रजिस्टर फ्लिप-फ्लॉप तार्किक शून्य स्थिति में हैं, यानी। Q0=0, Q1=0, Q2=0, Q3=0. यदि डी-फ्लिप-फ्लॉप टी1 के इनपुट पर तार्किक 0 है, तो फ्लिप-फ्लॉप के इनपुट "सी" पर क्लॉक पल्स के आगमन से उनकी स्थिति नहीं बदलती है।

जैसा कि चित्र 4.15 से पता चलता है, क्लॉक पल्स एक साथ सभी रजिस्टर ट्रिगर्स के संबंधित इनपुट पर पहुंचते हैं और उनमें रिकॉर्ड करते हैं कि उनके सूचना इनपुट पर क्या होता है। ट्रिगर्स T2, T3, T4 के सूचना इनपुट पर तार्किक "0" स्तर होते हैं, क्योंकि बाद के फ्लिप-फ्लॉप के सूचना इनपुट पिछले फ्लिप-फ्लॉप के आउटपुट से जुड़े होते हैं, जो तार्किक "0" स्थिति में होते हैं, और, उदाहरण के अनुसार, "0" पहले के इनपुट "डी" को आपूर्ति की जाती है। किसी बाहरी सूचना स्रोत से फ़्लिप-फ़्लॉप।

जब पहला ट्रिगर "1" इनपुट "डी" पर लागू किया जाता है, तो पहली घड़ी पल्स के आगमन के साथ, इस ट्रिगर पर "1" लिखा जाएगा, और अन्य ट्रिगर्स पर "0" लिखा जाएगा, क्योंकि जब तक घड़ी की पल्स का अगला भाग आया, तब तक ट्रिगर T1 के आउटपुट पर एक तार्किक "0" "अभी भी" मौजूद था। इस प्रकार, सूचना (वह बिट) जो घड़ी की पल्स के सामने आने के समय उसके इनपुट "डी" पर थी, आदि को टी1 ट्रिगर पर लिखा जाता है।

जब दूसरी घड़ी पल्स आती है, तो पहले ट्रिगर के आउटपुट से तार्किक "1" दूसरे ट्रिगर पर लिखा जाता है, और परिणामस्वरूप, प्रारंभिक रूप से लिखा गया "1" ट्रिगर टी1 से ट्रिगर टी2 में, ट्रिगर टी2 से ट्रिगर टी2 में स्थानांतरित हो जाता है। ट्रिगर T3, आदि। इस प्रकार, रजिस्टर इनपुट (एक सीरियल कोड में) पर आने वाली जानकारी का क्रमिक बदलाव प्रत्येक घड़ी चक्र में एक बिट द्वारा दाईं ओर किया जाता है।

एम क्लॉक पल्स आने के बाद, रजिस्टर पूरी तरह से सीरियल इनपुट "डी" के माध्यम से दर्ज संख्या के बिट्स से भर जाता है।

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

प्रतिवर्ती शिफ्ट रजिस्टर फॉरवर्ड और रिवर्स शिफ्ट रजिस्टर के गुणों को जोड़ते हैं।

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

में परिवर्तन की दिशा के नाम के संबंध में शिफ्ट रजिस्टरअक्सर भ्रम की स्थिति रहती है. शिफ्ट दो प्रकार की होती है: दाईं ओर (मुख्य मोड जो हर किसी के पास होता है शिफ्ट रजिस्टर) और बायीं ओर (केवल कुछ, उलटे, में यह मोड है शिफ्ट रजिस्टर). ये नाम आंतरिक संरचना को दर्शाते हैं शिफ्ट रजिस्टर(चित्र 8.14) और ट्रिगर्स की एक श्रृंखला के साथ संकेतों को क्रमिक रूप से फिर से लिखना। इस मामले में, फ्लिप-फ्लॉप, काफी स्वाभाविक रूप से, बाएं से दाएं क्रमांकित होते हैं, उदाहरण के लिए, 8-बिट रजिस्टरों के लिए 0 से 7 (या 1 से 8 तक)। परिणामस्वरूप, किसी रजिस्टर द्वारा जानकारी को दाईं ओर स्थानांतरित करना उच्च संख्या वाले बिट्स की ओर एक बदलाव है, और रजिस्टर द्वारा जानकारी को बाईं ओर स्थानांतरित करना कम संख्या वाले बिट्स की ओर एक बदलाव है।

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

चावल। 8.14.

डिजिटल माइक्रो सर्किट की मानक श्रृंखला में कई प्रकार शामिल हैं शिफ्ट रजिस्टर, संभावित ऑपरेटिंग मोड, लिखने, पढ़ने और शिफ्ट मोड के साथ-साथ आउटपुट चरणों के प्रकार (2C या 3C) में भिन्नता। बहुमत शिफ्ट रजिस्टरआठ अंक हैं. चित्र में. 8.15 उदाहरण के तौर पर चार प्रकार के माइक्रो सर्किट दिखाता है शिफ्ट रजिस्टर.

IR8 रजिस्टर सबसे सरल है शिफ्ट रजिस्टर. यह एक 8-बिट विलंब रेखा है, अर्थात, इसमें केवल एक सूचना इनपुट है, जिसमें क्रमिक रूप से स्थानांतरित जानकारी (अधिक सटीक रूप से, 2I फ़ंक्शन का उपयोग करके संयुक्त दो इनपुट) और आठ समानांतर आउटपुट की आपूर्ति की जाती है। उच्च संख्या वाले आउटपुट की ओर बदलाव अग्रणी किनारे के साथ किया जाता है घड़ी का संकेतसी. शून्य सिग्नल पर एक रीसेट इनपुट-आर भी है, जिस पर सभी रजिस्टर आउटपुट शून्य पर रीसेट हो जाते हैं। ट्रुथ टेबलरजिस्टर IR8 तालिका में दिया गया है। 8.5.

चावल। 8.15.तालिका 8.5. ट्रुथ टेबलशिफ्ट रजिस्टर IR8

इनपुट				बाहर निकलता है
-आर	सी	डी1	डी2	प्र0	Q1	क्यू 7
0	एक्स	एक्स	एक्स	0	0	0
1	0	एक्स	एक्स	मत बदलो
1	1	एक्स	एक्स	मत बदलो
1	0 1	1	1	1	प्र0	Q6
1	0 1	0	एक्स	0	प्र0	Q6
1	0 1	एक्स	0	0	प्र0	Q6

IR9 रजिस्टर IR8 रजिस्टर का उलटा कार्य करता है। यदि IR8 इनपुट सीरियल जानकारी को आउटपुट समानांतर जानकारी में परिवर्तित करता है, तो रजिस्टर IR9 इनपुट समानांतर जानकारी को आउटपुट सीरियल जानकारी में परिवर्तित करता है। हालाँकि, बदलाव का सार नहीं बदलता है, यह सिर्फ इतना है कि IR9 में सभी आंतरिक ट्रिगर्स में समानांतर इनपुट होते हैं, और केवल एक, अंतिम ट्रिगर में एक आउटपुट होता है (प्रत्यक्ष और उलटा दोनों)। इनपुट कोड -WR इनपुट पर शून्य सिग्नल के आधार पर रजिस्टर में लिखा जाता है। यह बदलाव संयुक्त रूप से दो क्लॉक इनपुट C1 और C2 में से एक पर सकारात्मक किनारे पर किया जाता है

किसी समय, आप अनिवार्य रूप से अपने प्रोजेक्ट या प्रोटोटाइप की जरूरतों को पूरा करने के लिए अपने Arduino पर पर्याप्त पिन न होने की समस्या का सामना करेंगे। इस समस्या का समाधान? शिफ्ट रजिस्टर, या बल्कि Arduino शिफ्ट रजिस्टर 74hc595।

जिस किसी ने भी Arduino प्रोजेक्ट किए हैं, जहां वे बहुत सारे एलईडी का उपयोग करते हैं, उन्होंने महसूस किया है कि वे काफी हद तक Arduino पिन द्वारा सीमित हैं और बड़ी संख्या में पिन की आवश्यकता वाले बड़े प्रोजेक्ट नहीं बना सकते हैं। हमारे विशेष प्रोजेक्ट में, 16 LED को केवल तीन Arduino पिन द्वारा नियंत्रित किया जाता है। मुख्य तत्व Arduino 74hc595 शिफ्ट रजिस्टर है। प्रत्येक 74एचसी595 शिफ्ट रजिस्टर 8 एलईडी तक स्वीकार कर सकता है, और रजिस्टरों की अनुक्रमिक श्रृंखलाओं का उपयोग करके, आप बोर्ड संपर्कों को पारंपरिक 3 से अनंत संख्या तक बढ़ा सकते हैं।

इससे पहले कि हम चिप कनेक्ट करना शुरू करें, आइए देखें कि प्रक्रिया कैसे काम करती है।

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

चिप में आठ पिन होते हैं जिनका उपयोग हम आउटपुट के लिए कर सकते हैं, प्रत्येक पिन एक रजिस्टर में एक बिट से जुड़ा होता है। 74HC595 शिफ्ट रजिस्टर के मामले में, हम उन्हें QA से QH तक देखते हैं।

Arduino के माध्यम से इन आउटपुट को लिखने के लिए हमें शिफ्ट रजिस्टर में एक बाइनरी मान भेजना होगा और उस नंबर से शिफ्ट रजिस्टर यह निर्धारित कर सकता है कि कौन से आउटपुट का उपयोग करना है। उदाहरण के लिए, यदि हमने बाइनरी मान 10100010 भेजा है, तो ऊपर की छवि में हरे रंग में हाइलाइट किए गए संपर्क सक्रिय होंगे और लाल रंग में हाइलाइट किए गए संपर्क निष्क्रिय होंगे।

इसका मतलब यह है कि सबसे दाहिना बिट QH पर मैप किया गया है और सबसे बायां बिट QA पर मैप किया गया है। किसी आउटपुट को तब सक्रिय माना जाता है जब उससे संबद्ध बिट को 1 पर सेट किया जाता है। इसे याद रखना महत्वपूर्ण है क्योंकि अन्यथा आपको यह जानने में बहुत कठिनाई होगी कि आप कौन से पिन का उपयोग कर रहे हैं।

अब जब हमें इस बात की बुनियादी समझ हो गई है कि हम किस पिन का उपयोग करना है यह निर्दिष्ट करने के लिए बिट ऑफसेट का उपयोग कैसे करते हैं, तो हम इसे अपने Arduino से कनेक्ट करना शुरू कर सकते हैं।

हम 8 एलईडी से शुरुआत करते हैं

पाठ के पहले भाग के लिए हमें निम्नलिखित घटकों की आवश्यकता होगी:

अरुडिनो यूनो
ब्रेड बोर्ड
Arduino शिफ्ट रजिस्टर 74HC595
8 एल.ई.डी
8 प्रतिरोधक - 220 ओम पर्याप्त होना चाहिए
तार/जम्पर

अपने लेआउट पर शिफ्ट रजिस्टर रखकर प्रारंभ करें, यह सुनिश्चित करते हुए कि प्रत्येक पक्ष लेआउट के एक अलग तरफ है, जैसा कि नीचे दिखाया गया है।

अक्षरों को ऊपर की ओर रखते हुए, बाईं ओर ऊपर से नीचे तक 1-8 पिन करें और दाईं ओर ऊपर से नीचे तक 16 - 9 पिन करें, जैसा कि नीचे चित्र में दिखाया गया है।

सर्किट को असेंबल करना

सबसे पहले, पिन 16 (VCC) और 10 (SRCLR) को Arduino पर 5v आउटपुट से कनेक्ट करें और पिन 8 (GND) और 13 (OE) को Arduino पर Gnd पिन से कनेक्ट करें। पिन 13 (OE) का उपयोग आउटपुट को सक्षम करने के लिए किया जाता है क्योंकि यह एक सक्रिय लो पिन है जिसे हम सीधे जमीन से जोड़ सकते हैं।

आगे हमें तीन पिन कनेक्ट करने की आवश्यकता है जिनका उपयोग हम शिफ्ट रजिस्टर को नियंत्रित करने के लिए करेंगे:

Arduino पर 11 पिन करने के लिए 74HC595 शिफ्ट रजिस्टर का पिन 11 (SRCLK) - इसे "सिंक पिन" कहा जाएगा
Arduino पर 12 पिन करने के लिए शिफ्ट रजिस्टर का पिन 12 (RCLK) - इसे "लैच पिन" कहा जाएगा।
Arduino पर 13 पिन करने के लिए शिफ्ट रजिस्टर का पिन 14 (SER) - इसे "डेटा पिन" कहा जाएगा

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

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

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

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

Arduino के लिए स्केच

अब हम कोड अपलोड करने के लिए तैयार हैं। अपने Arduino को अपने कंप्यूटर से कनेक्ट करें और इसमें 74hc595 Arduino के लिए निम्नलिखित स्केच डाउनलोड करें:

इंट लैचपिन = 12; इंट क्लॉकपिन = 11; पूर्णांक डेटापिन = 13; बाइट एल ई डी = 0; int currentLED = 0; शून्य सेटअप() (पिनमोड(लैचपिन, आउटपुट); पिनमोड(डेटापिन, आउटपुट); पिनमोड(क्लॉकपिन, आउटपुट); एलईडी = 0; ) शून्य लूप() (एलईडी = 0; यदि (वर्तमानएलईडी == 7) (वर्तमानएलईडी = 0; ) अन्य (करंटएलईडी++; ) बिटसेट(एलईडी, करंटएलईडी); शिफ्टआउट(डेटापिन, क्लॉकपिन, एलईडी);

सबसे पहले, आइए स्केच के शीर्ष पर निम्नलिखित को परिभाषित करें:

पिन स्थान: सिंक्रोनाइज़र, लैच और डेटा
एक बाइट जो बिट्स को संग्रहीत करेगी जो शिफ्ट रजिस्टर को बताएगी कि किस पिन का उपयोग करना है
एक वैरिएबल जो इस बात पर नज़र रखेगा कि हमें कौन सी एलईडी चालू करनी चाहिए

विधि में स्थापित करनाहम बस पिन मोड और एलईडी वेरिएबल को इनिशियलाइज़ करते हैं।

विधि में कुंडली(लूप) हम वेरिएबल में बिट्स को साफ़ करते हैं एल ई डीप्रत्येक पुनरावृत्ति की शुरुआत में, इसलिए सभी बिट्स 0 पर सेट होते हैं क्योंकि हम एक समय में केवल एक एलईडी चालू करना चाहते हैं। इसके बाद हम वर्तमान वेरिएबल को बढ़ाते या पुनः आरंभ करते हैं वर्तमानएलईडीफिर सही एलईडी को फिर से चालू करें।

इन दो ऑपरेशनों के बाद, हम अधिक महत्वपूर्ण भाग - बिट शिफ्टिंग की ओर बढ़ते हैं। सबसे पहले हम विधि को कॉल करके प्रारंभ करते हैं बिटसेट. हम विधि को पास करते हैं बिटसेटएक बाइट जो बिट्स को संग्रहीत करता है, और एक वेरिएबल वर्तमानएलईडी.

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

बिटसेट(एल ई डी, 1); बिटसेट(एल ई डी, 4);

इसलिए हर बार हम वर्तमान वेरिएबल को बढ़ाते हैं वर्तमानएलईडीऔर इसे विधि में पास करें बिटसेट, हम हर बार पिछले वाले के बाईं ओर के बिट को 1 पर सेट करते हैं और इस प्रकार शिफ्ट रजिस्टर को पिछले वाले के बाईं ओर के आउटपुट को सक्रिय करने के लिए कहते हैं।

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

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

16 एल.ई.डी

अब आइए 16 एलईडी के लिए 74hc595 Arduino का उपयोग करके अधिक जटिल सर्किट पर आगे बढ़ें।

विवरण

कुल मिलाकर, इस मामले में हम Arduino Uno को छोड़कर, सभी घटकों की संख्या को दोगुना कर देते हैं:

अरुडिनो यूएनओ (x1)
74एचसी595 शिफ्ट रजिस्टर (x2)
एल ई डी (x16)
220 ओम प्रतिरोधक (x16)
तार/जम्पर
दो विकास बोर्ड (एक 400 पिन के साथ, दूसरा 830 पिन के साथ)
चमक को नियंत्रित करने के लिए पोटेंशियोमीटर (वैकल्पिक)

कनेक्शन आरेख

कनेक्शन आरेख पहले से ही 8 एलईडी और एक 74HC595 शिफ्ट रजिस्टर से बड़ा है।

उपरोक्त चित्र के अनुसार सर्किट को असेंबल करें और पहले शिफ्ट रजिस्टर को निम्नानुसार कनेक्ट करें:

जीएनडी (पिन 8) जमीन पर
वीसीसी (पिन 16) - 5 वी
OE (पिन 13) से ग्राउंड (GND)
एमआर (पिन 10) - 5 वी
डीएस (पिन 14) - अरुडिनो का पिन 11
SH_CP (पिन 11) से Arduino पिन 12
Arduino के 8 को पिन करने के लिए ST_CP (पिन 12)।

दूसरे शिफ्ट रजिस्टर को भी इसी तरह कनेक्ट करें, लेकिन डीएस (पिन 14) को रजिस्टर के पहले पिन 9 से कनेक्ट करें। इसके बाद रजिस्टर और एलईडी दोनों से पिन 1, 2, 3, 4, 5, 6, 7 और 15 को कनेक्ट करें। यह कनेक्शन सभी पिनों को हमेशा सक्रिय और पता योग्य बनाता है, हालाँकि, जब आप Arduino चालू करते हैं, तो कुछ LED चालू हो सकते हैं। इसका समाधान MR (पिन 10) और OE (पिन 13) को सीधे Arduino से जोड़ना है, लेकिन इस तरह आपको Arduino के 2 पिन का त्याग करना होगा।

अधिक शिफ्ट रजिस्टर जोड़ने के लिए, उन्हें दूसरे रजिस्टर के रूप में एक साथ जोड़ें। हमेशा MR और OE पिन को सीधे Arduino पिन से और DS पिन को पिछले रजिस्टर से कनेक्ट करें। यदि आप एलईडी की चमक को समायोजित करना चाहते हैं, तो कृपया सभी एलईडी के प्रतिरोध को नियंत्रित करने के लिए ऊपर चित्र में दिखाए अनुसार एक पोटेंशियोमीटर कनेक्ट करें। हालाँकि, यह वैकल्पिक है और आप इसके बिना भी काम कर सकते हैं।

Arduino के लिए स्केच

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

int latchPin = 8; int क्लॉकपिन = 12; पूर्णांक डेटापिन = 11; int numOfRegisters = 2; बाइट* रजिस्टरस्टेट; लंबा प्रभावआईडी = 0; लंबे समय तक प्रभाव = 0; लंबा प्रभावदोहराएँ = 0; लंबी प्रभाव गति = 30; शून्य सेटअप() ( //आरंभ सरणी रजिस्टरस्टेट = नया बाइट; के लिए (size_t i = 0; i< numOfRegisters; i++) { registerState[i] = 0; } //set pins to output so you can control the shift register pinMode(latchPin, OUTPUT); pinMode(clockPin, OUTPUT); pinMode(dataPin, OUTPUT); } void loop() { do{ effectId = random(6); } while (effectId == prevEffect); prevEffect = effectId; switch (effectId) { case 0: effectRepeat = random(1, 2); break; case 1: effectRepeat = random(1, 2); break; case 3: effectRepeat = random(1, 5); break; case 4: effectRepeat = random(1, 2); break; case 5: effectRepeat = random(1, 2); break; } for (int i = 0; i < effectRepeat; i++) { effectSpeed = random(10, 90); switch (effectId) { case 0: effectA(effectSpeed); break; case 1: effectB(effectSpeed); break; case 3: effectC(effectSpeed); break; case 4: effectD(effectSpeed); break; case 6: effectE(effectSpeed); break; } } } void effectA(int speed){ for (int i = 0; i < 16; i++){ for (int k = i; k < 16; k++){ regWrite(k, HIGH); delay(speed); regWrite(k, LOW); } regWrite(i, HIGH); } } void effectB(int speed){ for (int i = 15; i > < i; k++){ regWrite(k, HIGH); delay(speed); regWrite(k, LOW); } regWrite(i, HIGH); } } void effectC(int speed){ int prevI = 0; for (int i = 0; i < 16; i++){ regWrite(prevI, LOW); regWrite(i, HIGH); prevI = i; delay(speed); } for (int i = 15; i >= 0; i--)( regWrite(prevI, LOW); regWrite(i, HIGH); prevI = i; देरी(गति); ) ) void प्रभावD(int गति)( for (int i = 0; i< 8; i++){ for (int k = i; k < 8; k++) { regWrite(k, HIGH); regWrite(15 - k, HIGH); delay(speed); regWrite(k, LOW); regWrite(15 - k, LOW); } regWrite(i, HIGH); regWrite(15 - i, HIGH); } } void effectE(int speed){ for (int i = 7; i >= 0; i--)( for (int k = 0; k<= i; k++) { regWrite(k, HIGH); regWrite(15 - k, HIGH); delay(speed); regWrite(k, LOW); regWrite(15 - k, LOW); } regWrite(i, HIGH); regWrite(15 - i, HIGH); } } void regWrite(int pin, bool state){ //Determines register int reg = pin / 8; //Determines pin for actual register int actualPin = pin - (8 * reg); //Begin session digitalWrite(latchPin, LOW); for (int i = 0; i < numOfRegisters; i++){ //Get actual states for register byte* states = ®isterState[i]; //Update state if (i == reg){ bitWrite(*states, actualPin, state); } //Write shiftOut(dataPin, clockPin, MSBFIRST, *states); } //End session digitalWrite(latchPin, HIGH); }

कोड इन 16 एलईडी के लिए कई प्रभाव जोड़ता है। यदि आप अधिक एलईडी जोड़ना चाहते हैं, तो ऊपर की तरह अधिक शिफ्ट रजिस्टर कनेक्ट करें और मान बदलें numOfRegistersकोड में.

आप इस कोड का उपयोग केवल LED से अधिक के लिए भी कर सकते हैं, यदि आपको अपने Arduino के लिए अधिक पिन की आवश्यकता है, तो किसी भी पिन की स्थिति लिखने के लिए regWrite(int Pin, bool state) फ़ंक्शन का उपयोग करें। और आप कितने शिफ्ट रजिस्टर का उपयोग करते हैं इसकी कोई सीमा नहीं है, बस numOfRegisters का मान बदलें और बाकी सब पहले से ही स्वचालित है।

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

जब मैंने माइक्रोकंट्रोलर्स से परिचित होना शुरू किया (वास्तव में, मैं अभी भी "परिचित होना शुरू कर रहा हूं"), तो पहले प्रश्नों में से एक था: आप नियंत्रक पर केवल एक दर्जन आउटपुट के साथ समान सौ, हजार एलईडी को कैसे नियंत्रित कर सकते हैं? हां, आप सिग्नल मल्टीप्लेक्सिंग, काउंटर-कनेक्शन और कई अन्य तरकीबों का उपयोग कर सकते हैं, लेकिन फिर भी कनेक्टेड एलईडी की अधिकतम संख्या सीमित है, और दूसरे समाधान की तलाश करना आवश्यक है। और उन्होंने मुझे एक विकल्प सुझाया - "एक, दो, दस शिफ्ट रजिस्टर चिप्स लें और आनंद लें।" उन्हें तुरंत ऑर्डर करने का निर्णय लिया गया, और भविष्य में उनका उपयोग करके एक एलईडी क्यूब भी इकट्ठा किया जाएगा। मुझे वास्तव में बाद वाला छोड़ना पड़ा; मुझे एक सरल विकल्प मिला, लेकिन यह एक अन्य समीक्षा का विषय है।
मैंने एक बार में 74HC595N के 20 टुकड़े ऑर्डर किए, सौभाग्य से उनकी कीमत मात्र एक पैसा थी। अंकन के अंत में अक्षर N का अर्थ है कि माइक्रोक्रिकिट DIP-16 पैकेज में है, जो ब्रेडबोर्ड पर प्रयोगों के लिए बहुत सुविधाजनक है, आपको कुछ भी सोल्डर करने की भी आवश्यकता नहीं है; यह इस तरह दिख रहा है:

यह माइक्रो सर्किट क्या है? यह एक आठ-बिट सीरियल-इन, सीरियल-आउट, या समानांतर-आउट शिफ्ट रजिस्टर है जिसमें एक लैच फ्लिप-फ्लॉप और तीन-स्टेट आउटपुट होता है।
सीधे शब्दों में कहें तो केवल 3 कंट्रोलर आउटपुट का उपयोग करके आप 8 शिफ्ट रजिस्टर आउटपुट को नियंत्रित कर सकते हैं। और यदि माइक्रो सर्किट एक के बाद एक श्रृंखला में जुड़े हुए हैं, तो नियंत्रित आउटपुट की संख्या को किसी भी उचित सीमा तक बढ़ाया जा सकता है (मुझे अधिकतम संख्या नहीं मिली है, लेकिन सैकड़ों बिना किसी समस्या के संयुक्त प्रतीत होते हैं; यदि कोई जानता है कि अधिकतम क्या है) कैस्केड में शामिल माइक्रो-सर्किट की संख्या इस पर निर्भर करती है, टिप्पणियों में यह जानना दिलचस्प होगा)।
डेटा को चिप में क्रमिक रूप से प्रसारित किया जाता है। बिट्स 0 और 1 को एक के बाद एक रजिस्टर में स्थानांतरित किया जाता है, क्लॉक पल्स आने पर बिट्स पढ़े जाते हैं। 8 बिट्स प्रेषित - रजिस्टर आउटपुट पर 8 आउटपुट स्टेट्स प्राप्त हुए। जब 74एचसी595 को कैस्केड किया जाता है (यदि 16, 24, आदि आउटपुट की आवश्यकता होती है), तो पहले रजिस्टर से डेटा अगले में स्थानांतरित कर दिया जाता है।
रजिस्टर आउटपुट न केवल तार्किक 0 या 1 स्थिति में हो सकता है, बल्कि सर्किट से आउटपुट डिस्कनेक्ट होने पर उच्च प्रतिबाधा स्थिति में भी हो सकता है। केवल सभी आउटपुट को एक बार में इस स्थिति में स्थानांतरित किया जा सकता है। इसका उपयोग शायद ही कभी किया जाता है, लेकिन उदाहरण के लिए, नियंत्रण को किसी अन्य नियंत्रक पर स्विच करते समय उपयोगी हो सकता है।

इनपुट/आउटपुट पिनआउट

Q0…Q7 - रजिस्टर आउटपुट, राज्य 0, 1 या उच्च प्रतिबाधा में हो सकता है
जीएनडी - जमीन
Q7′ - रजिस्टरों के सीरियल कनेक्शन के लिए आउटपुट।
एमआर - रजिस्टर रीसेट
SH_CP - क्लॉक इनपुट
ST_CP - डेटा लैचिंग इनपुट
OE - आउटपुट को उच्च प्रतिबाधा से ऑपरेटिंग स्थिति में परिवर्तित करने वाला इनपुट
डीएस - डेटा इनपुट
वीसीसी - बिजली आपूर्ति 2-6 वोल्ट

जो कुछ बचा है वह काम की जांच करना है; ऐसा करने के लिए, हम एक सर्किट इकट्ठा करेंगे जो शुरुआती लोगों के बीच लोकप्रिय है। जीएनडी (पिन 8) जमीन से जुड़ा है, वीसीसी (पिन 16) 5वी बिजली आपूर्ति से, ओई (पिन 13) जमीन से, एमआर (पिन 10) 5वी बिजली आपूर्ति से जुड़ा है। शिफ्ट रजिस्टर अब चालू हो गया है और सभी आउटपुट सक्रिय हैं। अब माइक्रोसर्किट को Arduino से कनेक्ट करने का समय है: DS डेटा इनपुट (पिन 14) को Arduino के 9वें डिजिटल आउटपुट, SH_CP क्लॉक इनपुट (पिन 11) को 10वें डिजिटल आउटपुट, ST_CP लैच इनपुट (पिन 12) से कनेक्ट करें। ) 8वें Arduino पिन तक। शोर को कम करने के लिए जमीन और कुंडी के बीच 0.1 μF कैपेसिटर लगाने की सिफारिश की जाती है।
यह एल ई डी को जोड़ने के लिए बना हुआ है - 150-300 ओम प्रतिरोधों के माध्यम से हम उन्हें रजिस्टर आउटपुट से जमीन तक जोड़ते हैं। बस इतना ही। यहां एक आरेख है जो मैंने उन लोगों के लिए पाया है जो दृश्य सामग्री पसंद करते हैं (कृपया ध्यान दें कि वास्तविक माइक्रोक्रिकिट का पिनआउट और इस आरेख पर योजनाबद्ध छवि अलग-अलग हैं!)

मैंने सर्किट को ब्रेडबोर्ड पर इकट्ठा किया, और यह इस तरह निकला।

इकट्ठे सर्किट

Arduino में,shiftOut() फ़ंक्शन का उपयोग करना सुविधाजनक है, जो सूचना के एक बाइट को इनपुट/आउटपुट पोर्ट पर क्रमिक रूप से (बिट दर बिट) आउटपुट करता है। . हम परीक्षण कोड को Arduino में लोड करते हैं और बाइनरी फॉर्म में 0 से 255 तक एक काउंटर प्राप्त करते हैं:
int latchPin = 8; //ST_CP पूर्णांक क्लॉकपिन = 10; //SH_CP पूर्णांक डेटापिन = 9; //डीएस शून्य सेटअप() (पिनमोड(लैचपिन, आउटपुट); पिनमोड(क्लॉकपिन, आउटपुट); पिनमोड(डेटापिन, आउटपुट); ) शून्य लूप() ((int numberToDisplay = 0; numberToDisplay के लिए)< 256; numberToDisplay++) { // установка синхронизации "защелки" на LOW digitalWrite(latchPin, LOW); // передаем последовательно на вход данных shiftOut(dataPin, clockPin, MSBFIRST, numberToDisplay); //"защелкиваем" регистр, устанавливаем значения на выходах digitalWrite(latchPin, HIGH); delay(500); } }
मेरे साथ ऐसा ही हुआ, सब कुछ उम्मीद के मुताबिक काम करता है:

इस प्रकार, नियंत्रक पिन के न्यूनतम उपयोग के साथ, आप बड़ी संख्या में एलईडी (या कुछ और) को नियंत्रित कर सकते हैं। सब कुछ ठीक होगा, लेकिन मैं आपको कमियों के बारे में भी बताऊंगा। जैसा कि आप देख सकते हैं, प्रत्येक एलईडी के लिए करंट एक अवरोधक द्वारा सीमित होना चाहिए, और बड़े एलईडी मैट्रिसेस बनाते समय यह काफी श्रम-गहन हो जाता है। एलईडी को नियंत्रित करने के लिए एक और दिलचस्प समाधान है - DM13A ड्राइवर, जो एक शिफ्ट रजिस्टर है और प्रत्येक आउटपुट पर करंट को भी सीमित करता है। मैं आपको अगली बार इसके बारे में बताऊंगा, और एक बोनस के रूप में - मेरा पहला एलईडी क्यूब, 5x5x5, 74HC595 के उपयोग के बिना, एक सरलीकृत तत्व आधार पर इकट्ठा किया गया।

मैं +37 खरीदने की योजना बना रहा हूं पसंदीदा में जोड़े मुझे समीक्षा पसंद आयी +35 +61