7 सेगमेंट डिस्प्ले पिक्चर माइक्रोकंट्रोलर के साथ इंटरफेस करता है

यह MPLAB और XC8 का उपयोग करते हुए PIC PIC माइक्रोकंट्रोलर्स सीखने का हमारा 8 वां ट्यूटोरियल है । हम MPLABX को PIC MCU के साथ एक एलसीडी का उपयोग करने से स्थापित करने के लिए सभी तरह से आए हैं। यदि आप यहां नए हैं, तो पिछले ट्यूटोरियल देखें जहां आप टाइमर, ब्लिंकिंग एलईडी, इंटरफेसिंग एलसीडी आदि सीख सकते हैं। आप यहां हमारे सभी PIC ट्यूटोरियल पा सकते हैं। अपने अंतिम ट्यूटोरियल में हमने देखा कि हम अपने 16 * 2 एलसीडी डिस्प्ले के साथ कस्टम कैरेक्टर कैसे जेनरेट कर सकते हैं, अब हम अपने सेल्फी को दूसरे प्रकार के डिस्प्ले मॉड्यूल से लैस करते हैं जिसे 7-सेगमेंट डिस्प्ले कहते हैं और इसे PIC माइक्रोकंट्रोलर के साथ इंटरफेस करते हैं ।

हालाँकि 16x2 LCD 7-सेगमेंट डिस्प्ले की तुलना में बहुत अधिक आरामदायक है लेकिन कुछ परिदृश्य हैं जहाँ एक LCD डिस्प्ले की तुलना में 7-सेगमेंट का डिस्प्ले काम में आएगा। एलसीडी कम चरित्र के आकार के दोष से ग्रस्त है और यदि आप कुछ संख्यात्मक मूल्यों को प्रदर्शित करने की योजना बना रहे हैं तो यह आपके प्रोजेक्ट के लिए ओवरकिल होगा। 7-सेगमेंट में खराब रोशनी की स्थिति के खिलाफ भी लाभ है और इसे एक सामान्य एलसीडी स्क्रीन की तुलना में लेगर एंगल से देखा जा सकता है। तो, हम इसे जानना शुरू करते हैं।

7-सेगमेंट और 4-अंक 7-सेगमेंट डिस्प्ले मॉड्यूल:

7 सेगमेंट डिस्प्ले में इसके सात सेगमेंट हैं और प्रत्येक सेगमेंट में इसी सेगमेंट को लाइट करके नंबर प्रदर्शित करने के लिए इसके अंदर एक एलईडी है। जैसे अगर आप 7-सेगमेंट को "5" नंबर दिखाना चाहते हैं, तो आपको उनके संबंधित पिनों को ऊंचा करके सेगमेंट a, f, g, c और d को चमकाना होगा। 7-सेगमेंट डिस्प्ले के दो प्रकार हैं: कॉमन कैथोड और कॉमन एनोड, यहां हम कॉमन कैथोड सात सेगमेंट डिस्प्ले का उपयोग कर रहे हैं । यहां 7 सेगमेंट डिस्प्ले के बारे में अधिक जानें।

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

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

यह समझने के लिए कि 4-अंकीय सात सेगमेंट मॉड्यूल कैसे काम करते हैं, हमें उपरोक्त योजनाबद्धताओं पर गौर करना होगा, क्योंकि दिखाया गया है कि सभी चार डिस्प्ले का A पिन B के लिए A और A के समान है। तो, मूल रूप से यदि ए पर ट्रिगर होता है, तो सभी चार ए को उच्च दाएं जाना चाहिए?

लेकिन, ऐसा नहीं होता है। हमारे पास D0 से D3 (D0, D1, D2 और D3) में अतिरिक्त चार पिन हैं जिन्हें नियंत्रित करने के लिए इस्तेमाल किया जा सकता है जो चारों में से प्रदर्शित होते हैं जो उच्च स्तर पर जाने चाहिए। उदाहरण के लिए: यदि मुझे अपने आउटपुट की आवश्यकता केवल दूसरे डिस्प्ले पर मौजूद है, तो अन्य पिन (D0, D2, और D3) को कम रखते हुए केवल D1 को उच्च बनाया जाना चाहिए। बस हम यह चुन सकते हैं कि किस डिस्प्ले को D0 से D3 तक पिन का उपयोग करके सक्रिय होना है और A से DP तक पिन का उपयोग करके किस चरित्र को प्रदर्शित करना है।

PIC माइक्रोकंट्रोलर के साथ 4 अंकों के सात सेगमेंट मॉड्यूल को जोड़ना:

यहां हमने PIC माइक्रोकंट्रोलर PIC16F877A का उपयोग किया है और सर्किट के लिए योजनाबद्ध नीचे दिखाया गया है।

हमारे पास मॉड्यूल से 12 आउटपुट पिन हैं जिसमें से 8 का उपयोग वर्णों को प्रदर्शित करने के लिए किया जाता है और चार का उपयोग चार में से एक प्रदर्शन का चयन करने के लिए किया जाता है। इसलिए सभी 8 वर्ण पिन PORTD को सौंपे जाते हैं और प्रदर्शन चयन पिन PORTC के पहले चार पिनों को सौंपा जाता है।

नोट: मॉड्यूल का ग्राउंड पिन भी MCU के ग्राउंड से जुड़ा होना चाहिए जो यहां नहीं दिखाया गया है।

PIC16F877A का उपयोग करके प्रोग्रामिंग:

अब, जब हम जानते हैं कि यह मॉड्यूल वास्तव में कैसे काम करता है, तो आइए जानें कि कैसे PIC16F877A को प्रोग्राम करना है ताकि यह 4 अंकों की संख्या प्रदर्शित कर सके । हमें 0 से 1000 तक एक चर बढ़ाएँ और इसे 7-खंड प्रदर्शन पर प्रिंट करें। MPLABX प्रोग्राम लॉन्च करें और नए प्रोजेक्ट बनाएं, आइए हम कॉन्फ़िगरेशन बिट्स के साथ शुरू करते हैं।

#pragma config FOSC = HS // Oscillator Selection बिट्स (HS oscillator) #pragma config WDTE = OFF // वॉचडॉग टाइमर सक्षम करें बिट (WDT अक्षम) #pragma config PWRTE = ON (पावर-अप टाइमर सक्षम करें बिट (PWRT सक्षम) # pragma config BOREN = ON // ब्राउन-आउट रीसेट सक्षम करें (BOR सक्षम) #pragma config LVP = OFF // कम-वोल्टेज (एकल-आपूर्ति) इन-सर्किट सीरियल प्रोग्रामिंग बिट सक्षम करें (RB3 डिजिटल / O, HV है) MCLR का उपयोग प्रोग्रामिंग के लिए किया जाना चाहिए) #pragma config CPD = OFF // Data EEPROM मेमोरी कोड प्रोटेक्शन बिट (Data EEPROM कोड प्रोटेक्शन ऑफ) #pragma config WRT = OFF // फ्लैश प्रोग्राम मेमोरी राइट बिट्स सक्षम करें (प्रोटेक्शन ऑफ लिखें; सभी प्रोग्राम मेमोरी; EECON नियंत्रण द्वारा लिखा जा सकता है) #pragma config CP = OFF // फ़्लैश प्रोग्राम मेमोरी कोड प्रोटेक्शन बिट (कोड सुरक्षा बंद)

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

अगला हम डिस्प्ले के प्रत्येक अंक के बीच टॉगल करने के लिए आउटपुट पिन को परिभाषित करते हैं।

// *** सभी चार डिस्प्ले के सिग्नल पिन को परिभाषित करें *** // #define s1 RC0 #define s2 RC1 #define s3 RC2 #define s4 RC3 // *** परिभाषा का अंत ** ////

यहाँ पिन RC0, RC1, RC2 और RC3 का उपयोग हमारे 7-खंड प्रदर्शन मॉड्यूल के चार अंकों के बीच चयन के लिए किया जाता है। इन पिनों को क्रमशः s1, s2, s3 और s4 के रूप में परिभाषित किया गया है।

अगला हमें शून्य में कूदता है (), जिसके अंदर हम निम्नलिखित चर घोषणा करते हैं:

int i = 0; // 4-अंकीय मान जिसे इंट फ्लैग = 0 दिखाया जाना है; // अहस्ताक्षरित int बनाने के लिए a, b, c, d, e, f, g, h; // वेरिएबल अनसेंसर्ड int seg = {0X3F, // हेक्स वैल्यू नंबर 0 0X06, // हेक्स मान प्रदर्शित करने के लिए नंबर 1 0X5B, // हेक्स मान प्रदर्शित करने के लिए नंबर 2 0X4F, // हेक्स मान प्रदर्शित करने के लिए संख्या 3 0X66, // हेक्स मान संख्या 4 0X6D, // हेक्स मान प्रदर्शित करने के लिए संख्या 5 0X7C, // हेक्स मान संख्या 6 0X07, // हेक्स मान प्रदर्शित करने के लिए संख्या 7 0X6F, / प्रदर्शित करने के लिए / हेक्स मान संख्या 8 0X6F // हेक्स मान प्रदर्शित करने के लिए संख्या 9}; // 0 से 9 तक की संख्या प्रदर्शित करने के लिए ऐरे का अंत

यहाँ वैरिएबल i और फ़्लैग को प्रदर्शित किए जाने वाले मानों को संग्रहीत करने और क्रमशः देरी बनाने के लिए उपयोग किया जाता है। अहस्ताक्षरित पूर्णांक चर एक घंटे के लिए एकल अंक में चार अंकों की संख्या को तोड़ने और उन्हें स्टोर (जो बाद में यहां विस्तार से बताया जाएगा) किया जाता है।

यहां ध्यान देने वाली एक महत्वपूर्ण बात "सीग" ऐरे घोषणा है। इस कार्यक्रम में हम एक नए डेटा प्रकार का उपयोग कर रहे हैं जिसे ऐरे कहा जाता है। एरे समान डेटा-प्रकार के मूल्यों के संग्रह के अलावा कुछ भी नहीं है। यहां, हमने 0 से 9 तक की संख्या प्रदर्शित करने के लिए सभी समान हेक्स मानों को संग्रहीत करने के लिए इस सरणी का उपयोग किया है।

सरणी का पता हमेशा शून्य से शुरू होता है। इसलिए इस सरणी में पते में संग्रहीत संख्यात्मक संख्या (0-9) का हेक्स मान होगा जो नीचे दिए गए संख्या के समान है

चर:	सेग	सेग	सेग	सेग	सेग	सेग	सेग	सेग	सेग	सेग
हेक्स कोड:	0X3F	0X06	0X5B	0X4F	0X66	0X6D	0X7C	0X07	0X7F	0X6F
Eq। संख्यात्मक संख्या:	०	1	२	३	४	५	६	।	।	९

तो बस, अगर आप अपने 7-सेगमेंट पर नंबर 0 प्रदर्शित करना चाहते हैं तो आप seg को कॉल कर सकते हैं , इसी तरह अगर आप नंबर 6 को प्रदर्शित करना चाहते हैं तो आपको बस seg का उपयोग करना होगा ।

यह समझने के लिए कि वास्तव में एचईएक्स मूल्य कैसे प्राप्त किया गया था, हमें नीचे दी गई तालिका में देखें। प्रत्येक दशमलव संख्या के लिए बराबर हेक्स मान सरणी में संग्रहीत किया जाता है ताकि यह एक विशेष संख्या प्रदर्शित करने के कहा जा सकता है।

अब, हम कोड के अगले भाग पर चलते हैं जो I / O विन्यास है:

// ***** I / O कॉन्फ़िगरेशन **** // TRISC = 0X00; PORTC = 0X00; TRISD = 0x00; पोर्ट = 0X00; // *** I / O कॉन्फ़िगरेशन का अंत ** ///

I / O कॉन्फ़िगरेशन सरल है क्योंकि हमारे 7-खंड पर सभी पिन आउटपुट पिन हैं, और कनेक्शन ऊपर सर्किट आरेख में दिखाए गए हैं, इसलिए उन्हें केवल आउटपुट के रूप में घोषित करें और उन्हें शून्य से प्रारंभ करें।

अब हम अपने अनंत लूप में कूदते हैं (जबकि (1))। यहां हमें "i" के मूल्य को चार अंकों में विभाजित करना और उन्हें 7-खंड पर प्रदर्शित करना है। पहले "आइ" पर मान को विभाजित करके शुरू करते हैं

// *** चार अंकों में "i" विभाजित करना *** // a = i% 10; // 4 अंक को यहाँ सहेजा जाता है b = i / 10; c = b% 10; // 3 अंक यहाँ सहेजा गया है d = b / 10; ई = डी% 10; // 2 अंक यहाँ बचाया गया है f = d / 10; g = f% 10; // 1 अंक यहाँ h = f / 10 बचा है; // *** बंटवारे का अंत *** //

सरल मापांक और विभाजन ऑपरेशन का उपयोग करके 4 अंकों की संख्या (i) को अलग-अलग संख्याओं में विभाजित किया जाता है। हमारे मामले में हम एक उदाहरण लेते हैं जहां "i" का मान 4578 है। फिर इस प्रक्रिया के अंत में चर g = 4, e = 5, c = 7 और a = 8 है। इसलिए अब उस चर का उपयोग करके प्रत्येक अंक को प्रदर्शित करना आसान होगा।

PORTD = seg; s1 = 1; // प्रदर्शन 1 चालू करें और 4 अंक __delay_ms (5) प्रिंट करें; s1 = 0; // 5ms देरी PORTD = seg; s2 = 1 के बाद प्रदर्शन बंद करें 1; // प्रदर्शन 2 चालू करें और 3 अंक __delay_ms (5) प्रिंट करें; s2 = 0; // 5ms देरी PORTD = seg; s3 = 1 के बाद प्रदर्शन बंद करें 2; // प्रदर्शन 3 चालू करें और 2 अंक __delay_ms (5) प्रिंट करें; s3 = 0; // 5ms देरी PORTD = seg; s4 = 1 के बाद प्रदर्शन 3 बंद करें; // प्रदर्शन 4 चालू करें और 1 अंक __delay_ms (5) प्रिंट करें; s4 = 0; // 5ms देरी के बाद प्रदर्शन 4 को बंद करें

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

तो, हम इसके साथ कैसे जाते हैं?

हमारे लिए भाग्यशाली है कि हमारा MCU एक मानव आँख की तुलना में बहुत तेज़ है, इसलिए हम वास्तव में क्या करते हैं: हम एक समय में एक अंक प्रदर्शित करते हैं लेकिन हम इसे बहुत तेज़ी से करते हैं जैसा कि ऊपर दिखाया गया है ।

हम एक अंक का चयन करते हैं यह 5ms के लिए प्रतीक्षा करता है ताकि MCU और 7-खंड इसे संसाधित कर सकें और फिर उस अंक को बंद कर अगले अंक पर ले जाएं और जब तक हम अंतिम अंक तक नहीं पहुंचते तब तक ऐसा ही करें। 5ms की देरी को एक मानव आंख से नहीं देखा जा सकता है और सभी चार अंक एक ही समय में दिखाई देते हैं।

यह वह है, अंत में हम केवल देरी के रूप में प्रदर्शित अंक का मूल्य बढ़ाते हैं जैसा कि नीचे दिखाया गया है

if (झंडा> = 100) // प्रतीक्षा करें जब तक झंडा 100 {i ++; झंडा = 0 तक न पहुंच जाए; // केवल अगर झंडा सौ है "i" बढ़ जाएगा} झंडा ++; // प्रत्येक फ्लैश के लिए वेतन वृद्धि ध्वज

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

पूरा कोड नीचे दी गई है और इस प्रक्रिया को भी समझाया गया है वीडियो के अंत में।

हार्डवेयर सेटअप और परीक्षण:

जैसा कि हम वास्तव में हमारे हार्डवेयर के साथ जाने से पहले हमेशा प्रोटियस का उपयोग करके प्रोग्राम को अनुकरण करते हैं। यदि अनुकार सफल है, तो आपको कुछ ऐसा देखना चाहिए

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