आम एनोड 7-सेगमेंट, 4 अंकों के डिस्प्ले का उपयोग कैसे करें?

Question

कृपया इस प्रश्न को नीचे (मेरे अपने) उदाहरण के रूप में लें।

मुझे 7 सेगमेंट, 4 अंकों का एलईडी डिस्प्ले मिला है, लेकिन मुझे इस पर कोई आइडिया नहीं है कि इसे कैसे वायर किया जाए।

मुझे आम एनोड / कैथोड में अंतर समझ में नहीं आता है, और मेरे पास प्रति एलईडी 2 पिन नहीं हैं, जो अजीब है। काफी हाल ही में, "7 खंड 4 अंक आम एनोड" पर एक प्रश्न हटा दिया गया। उसी क्षण मैं एक उत्तर लिख रहा था।

हालाँकि, मैं अभी भी अपना उत्तर आपके साथ, या उस व्यक्ति से साझा करना चाहता हूं जिसने इसे पूछा था। कृपया अधिक जानकारी के साथ मेरे उत्तर को सत्यापित / अद्यतन करें। विशेष रूप से, कोई कार्य कोड जोड़ सकता है, मैं इस समय नहीं कर सकता।

Comments

बस उत्सुक। क्या आपने कोई प्रश्न पोस्ट किया है ताकि आप इसका उत्तर दे सकें?

— फिल्लीएनजे

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

— पॉल

Answer 1

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

यह वास्तव में एक सामान्य कैथोड डिस्प्ले है, इसलिए यह कार्यक्रम मानता है, साथ ही साथ आंकड़े की विशेष वायरिंग भी। दिलचस्प हिस्सा refresh_display()फ़ंक्शन है, जिसे समय-समय पर कहा जाना चाहिए। एल्गोरिथ्म इस प्रकार है:

• हम जिस अंक को दिखाना चाहते हैं, उसके लिए उपयुक्त संकेतों के साथ 7 एनोड ड्राइव करें
• HIGHएनपीएन ट्रांजिस्टर के माध्यम से उस अंक के कैथोड को नियंत्रित करने वाले आउटपुट को सेट करें
• 2.5 एमएस के लिए प्रतीक्षा करें (100 हर्ट्ज की ताज़ा दर के लिए)
• LOWकैथोड-कंट्रोलिंग आउटपुट सेट करें
• अगले अंक पर जाएं।

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

const int NB_DIGITS     = 4;  // 4-digit display
const int FIRST_ANODE   = 2;  // anodes a..g on pins 2..8
const int FIRST_CATHODE = 9;  // cathodes, right to left, on pins 9..12

// Digits to display, from right to left.
uint8_t digits[NB_DIGITS];

// Set all the used pins as outputs.
void init_display()
{
    for (int i = 0; i < 7; i++)
        pinMode(FIRST_ANODE + i, OUTPUT);
    for (int i = 0; i < NB_DIGITS; i++)
        pinMode(FIRST_CATHODE + i, OUTPUT);
}

// This should be called periodically.
void refresh_display()
{
    // Our 7-segment "font".
    static const uint8_t font[10] = {
        //abcdefg
        0b1111110, // 0
        0b0110000, // 1
        0b1101101, // 2
        0b1111001, // 3
        0b0110011, // 4
        0b1011011, // 5
        0b1011111, // 6
        0b1110000, // 7
        0b1111111, // 8
        0b1111011  // 9
    };

    // Wait for 2.5 ms before switching digits.
    static uint32_t last_switch;
    uint32_t now = micros();
    if (now - last_switch < 2500) return;
    last_switch = now;

    // Switch off the current digit.
    static uint8_t pos;
    digitalWrite(FIRST_CATHODE + pos, LOW);

    // Set the anodes for the next digit.
    pos = (pos + 1) % NB_DIGITS;
    uint8_t glyph = font[digits[pos]];
    for (int i = 0; i < 7; i++)
        digitalWrite(FIRST_ANODE + i, glyph & 1 << (6-i));

    // Switch digit on.
    digitalWrite(FIRST_CATHODE + pos, HIGH);
}

/***********************************************************************
 * Example usage.
 */

void setup()
{
    init_display();
}

void loop()
{
    uint32_t now = millis();

    // Change the number displayed every second.
    static uint32_t last_change;
    if (now - last_change >= 1000) {
        digits[3] = digits[2];
        digits[2] = digits[1];
        digits[1] = digits[0];
        digits[0] = (digits[0] + 1) % 10;
        last_change = now;
    }

    refresh_display();
}

पॉल ने Parallax पर एक ट्यूटोरियल का लिंक प्रदान किया जो मल्टीप्लेक्स 7Seg Arduino लाइब्रेरी का उपयोग करने का सुझाव देता है । वह पुस्तकालय ऊपर दिए गए उदाहरण कोड से अधिक सामान्य है, क्योंकि यह इस्तेमाल किए गए पिन के बारे में धारणा नहीं बनाता है। लेकिन पुस्तकालय और इस कोड के बीच का बड़ा अंतर उस तरह से है जैसे समय का प्रबंधन किया जाता है:

• पुस्तकालय टाइमर 2 अतिप्रवाह बाधा से प्रेरित है। यह एक बहुत ही स्थिर समय प्रदान करना चाहिए, इस काम के लिए समर्पित एक टाइमर की कीमत पर।
• उपर्युक्त कोड refresh_display()अक्सर उपयोगकर्ता के कॉलिंग पर निर्भर करता है। इसके लिए समर्पित हार्डवेयर संसाधनों की आवश्यकता नहीं है, लेकिन यह उन कार्यक्रमों के साथ अच्छी तरह से नहीं खेलता है जो बहुत लंबा समय लेते हैं loop(): यह आपको कॉल करना पसंद नहीं करेगा delay()।

Comments

यही कारण है कि मुझे ओपन-सोर्स सामान पसंद है। आप बाकी दुनिया के साथ काम का बोझ साझा कर सकते हैं और वास्तव में कुछ अच्छा बना सकते हैं। जिसे बाद में बाकी दुनिया के साथ फिर से साझा किया जाता है :) आप अन्य डेवलपर्स से बहुत कुछ सीख सकते हैं और यह ज्ञान लगातार रहेगा और हर किसी से छिपा हुआ नहीं होगा।

— पॉल

ट्रानिस्टर के आधार अवरोधक मूल्य के संबंध में मेरे मन में एक प्रश्न है। मुझे रोकनेवाला मूल्य की गणना के साथ एक बड़ी समस्या है। चार 2N2222 ट्रांजिस्टर में 4.7K रोकनेवाला का उपयोग करने का क्या कारण है? यदि एक एकल खंड 10mA का उपभोग करता है तो डीपी सहित सभी खंडों के लिए अधिकतम 80mA वर्तमान ड्राइंग होगा। यदि V (BE * sat) = 1.3v और I (B) = 15mA तो 300ohm पर्याप्त होगा। क्या मेरी गणना में कोई गड़बड़ है?

— 20

@maruf: न्यूनतम आवश्यक I_B न्यूनतम ट्रांजिस्टर लाभ द्वारा विभाजित I_C अपेक्षित है। यदि आप कलेक्टर पर 80 एमए चाहते हैं और कम से कम 100 का लाभ पाने की उम्मीद करते हैं (यह आशावादी हो सकता है, मैंने डेटाशीट की जांच नहीं की), तो आपको आधार पर कम से कम 80/100 = 0.8 एमए की आवश्यकता है। फिर आधार अवरोधक का अधिकतम मूल्य उस धारा द्वारा विभाजित वोल्टेज ड्रॉप (लगभग 5 V - 0.7 V) है, या लगभग 5.3 the है।

— एडगर बोनट

Answer 2

मैं कोशिश करूँगा और आपको एलईडी आदि की पूरी बुनियादी बातों के माध्यम से ले जाऊँगा। 4-अंकों के 7-सेगमेंट के डिस्प्ले कई "एलईडी तकनीकों" का संयोजन हैं।

वायरिंग एलईडी की

एलईडी, या लाइट एमिटिंग डायोड, Arduino की मजेदार चीजों में से एक हैं।

अनिवार्य रूप से, उनका उपयोग करना आसान है, उन्हें शक्ति प्रदान करें और वे प्रकाश करेंगे।

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

के रूप में यह कष्टप्रद है, यह भी काफी उपयोगी है।

कैथोड बनाम एनोड

एक पारंपरिक एलईडी पर, लंबी लीड (+), एनोड है। अन्य लीड (-) कैथोड है।

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

स्रोत: https://learn.sparkfun.com/tutorials/polarity/diode-and-led-polarity

बुनियादी तारों

मुझे यकीन नहीं है कि यह सही है, क्योंकि मैंने इंटरनेट से छवि को चीर दिया है।

एक एलईडी को तार करना काफी आसान है, एनोड (+) सकारात्मक वोल्टेज से जुड़ता है, अधिमानतः एक वर्तमान सीमित अवरोधक के माध्यम से। कैथोड (-) जमीन से जुड़ता है (वर्तमान सीमित अवरोधक के साथ, यदि आपके पास सकारात्मक पक्ष नहीं है)।

वर्तमान सीमित अवरोधक एलईडी को छोटा करने से बचाएगा, एलईडी या माइक्रोकंट्रोलर / अरुडिनो को नुकसान पहुंचाएगा।

एकाधिक एल ई डी, matrices, RGB एलईडी

कई एलईडी के साथ आप अक्सर उनके साथ जुड़े सकारात्मक पक्ष (+), "सामान्य एनोड" या सभी (-) "कॉमन कैथोड" से जुड़े होते हैं।

मूल रूप से यह नीचे आ जाएगा।

एक सामान्य कैथोड के लिए, आप उस पिन को करंट की आपूर्ति करते हैं जिसे आप चाहते हैं।

एक सामान्य एनोड के लिए, आप एलईडी के माध्यम से वर्तमान को सिंक करते हैं।

मल्टीप्लेक्सिंग (कई अंक, 7-खंड)

आपको लंबन के ट्यूटोरियल की जांच करनी चाहिए: http://learn.parallax.com/4-digit-7-segment-led-display-arduino-demo

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

आमतौर पर आप एलईडी के एक कॉलम से करंट को अलग करते हैं और एक पंक्ति के अलग-अलग एलईडी को आपूर्ति करते हैं।

या, आप LED के एक कॉलम में करंट सप्लाई करते हैं और अलग-अलग LED की एक पंक्ति से करंट को सिंक करते हैं।

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

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

इसलिए जब आपके पास 4 अंक है, तो 7 खंड, सामान्य एनोड का गुणा करें

आरेख इस तरह अधिक होगा:

http://www.mytutorialcafe.com/Microcontroller%20Application%20C%207segmen.htm