आपके पास पहले से मौजूद घटकों का उपयोग करके किसी भी प्रतिरोध/क्षमता को कैसे प्राप्त करें!: 6 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:18

यह सिर्फ एक और श्रृंखला/समानांतर समकक्ष प्रतिरोध कैलकुलेटर नहीं है! यह प्रोग्राम गणना करता है कि प्रतिरोधों/संधारित्रों को कैसे संयोजित किया जाए जिसे आपको वर्तमान में एक लक्ष्य प्रतिरोध/समाई मूल्य प्राप्त करना है जिसकी आपको आवश्यकता है।

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

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

कैलकुलेटर को आज़माने के लिए, इस वेब एप्लिकेशन पर जाएँ।

स्रोत कोड देखने के लिए, इस Github रिपॉजिटरी पर जाएँ।

कृपया मुझे बताएं कि क्या आपके पास इस डिज़ाइन टूल की उपयोगिता को और बेहतर बनाने के लिए कोई सुझाव है!

चरण 1: पृष्ठभूमि

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

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

f = 1 / (0.693×C×(R1 + 2×R2))

इस समीकरण का उपयोग करते हुए जहां R1 = 100 kOhm और R2 = 10 kOhm, मैंने गणना की कि एक 27.33 nF संधारित्र A4 नोट (आवृत्ति 440 Hz) का उत्पादन करेगा। अपने कार्यक्रम का उपयोग करते हुए, मैं.001 nF (एक मानक संधारित्र पर सहिष्णुता से बहुत कम) के भीतर एक समान समाई मूल्य की गणना करने में सक्षम था, जिसे मैं उन कैपेसिटर का उपयोग करके बना सकता हूं जो मेरे पास पहले से ही पड़ा हुआ था। परिणामी आउटपुट और कॉन्फ़िगरेशन नीचे वर्णित है। मैं अब अपने अंग को मानक नोटों की सटीक आवृत्तियों के लिए अधिक कुशलता से और प्रभावी ढंग से ट्यून करने में सक्षम हूं। काश मैंने इसे शुरू करने के लिए किया होता। अंग पर मेरा डेमो गीत शायद बहुत बेहतर लगता।

निकटतम मान: २७.३२९ एनएफ अंतर: ०.००१ एनएफ संधारित्र विन्यास: सी० = ०.०६८ एनएफ || सी1=30 एनएफ + सी2=300 एनएफ

प्रतिरोधी संधारित्र तुल्यता समीकरण

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

• श्रृंखला में प्रतिरोधक (R1 + R2): अनुरोध = R1 + R2
• समानांतर में प्रतिरोधक (R1 || R2): अनुरोध = 1 / (1/R1 + 1/R2)
• श्रृंखला में संधारित्र (C1 + C2): Ceq = 1 / (1/C1 + 1/C2)
• समानांतर में कैपेसिटर (C1 || C2): Ceq = C1 + C2

चरण 2: इनपुट

4 इनपुट हैं जिन्हें आपको प्रदान करने की आवश्यकता होगी:

1. चाहे आप किसी प्रतिरोधक या संधारित्र के मान की गणना कर रहे हों।
2. लक्ष्य प्रतिरोध या समाई मूल्य और इकाइयाँ।
3. लक्ष्य मान प्राप्त करने के लिए आप अधिकतम घटकों का उपयोग करना चाहेंगे (अर्थात मैं अपने लक्ष्य प्रतिरोध मान को प्राप्त करने के लिए 3 से अधिक प्रतिरोधों का उपयोग नहीं करना चाहूंगा)।
4. वर्तमान में आपके पास मौजूद प्रतिरोधों/संधारित्रों के लिए मूल्यों की सूची। ये मान आपके लक्ष्य मान के समान इकाइयों में होने चाहिए (अर्थात यदि आपका लक्ष्य मान 110 nF था, तो आपके सभी मान nF में प्रदान किए जाने चाहिए)।

चरण 3: परिणाम

आपको अपने परिणाम के लिए 3 आउटपुट मिलेंगे:

1. निकटतम मूल्य - निकटतम प्रतिरोध / समाई मूल्य जिसे आप अपने मापदंडों के साथ प्राप्त करने में सक्षम थे।
2. अंतर - आपका निकटतम मूल्य आपके लक्षित मूल्य से कितना दूर था।
3. रोकनेवाला/संधारित्र विन्यास - उपयोग करने के लिए प्रतिरोधों/संधारित्रों के मूल्यों और उनके विन्यास की एक सूची।

चरण 4: अपने परिणाम को समझना

कॉन्फ़िगरेशन आउटपुट एक मानक संकेतन का उपयोग करता है। "+" का अर्थ है कि घटक श्रृंखला में हैं और "||" इसका मतलब है कि घटक समानांतर में हैं। ऑपरेटरों की समान प्राथमिकता होती है और वे बाएं से दाएं सहयोगी होते हैं जिसका अर्थ है कि आप समूह की शर्तों को एक साथ बाएं से शुरू करते हैं और दाएं से आगे बढ़ते हैं।

उदाहरण के लिए, निम्न परिणाम पर एक नज़र डालें:

रोकनेवाला विन्यास: R0=15 ओम + R1=470 ओम || R2=3300 ओम + R3=15000 ओम

यदि आप ऊपर चर्चा किए गए दिशानिर्देशों का पालन करते हैं, तो आप देख सकते हैं कि यह निम्नलिखित समीकरण और ऊपर की छवि के बराबर है।

((R0+R1)||R2)+R3

चरण 5: अधिक परियोजनाएं

अधिक परियोजनाओं के लिए, मेरे पृष्ठों पर जाएँ:

• https://dargen.io/
• https://github.com/mjdargen
• https://www.instructables.com/member/mjdargen/

चरण 6: स्रोत कोड

सोर्स कोड देखने के लिए, इस जीथब रिपॉजिटरी पर जाएं या नीचे जावास्क्रिप्ट देखें।

/* --------------------------------------------------------------- */

/* r/c कैलकुलेटर स्क्रिप्टिंग */ /* --------------------------------------- ------------------------*/ वर निकटतम_वल; // अब तक का निकटतम मूल्य var निकटतम_diff = 1000000.00; // वैल का अंतर और लक्ष्य वर निकटतम = ; // सरणी घटकों के मूल्यों का विवरण var ser_par_config = ; // सरणी विवरण सीरियल/समानांतर var outputStr = ""; फ़ंक्शन कैलकुलेटरक्लिक () {// प्रत्येक नए क्लिक के लिए वैश्विक मूल्यों को साफ़ करें निकटतम_वल = 0; निकटतम_diff = 1000000.00; निकटतम = ; ser_par_config = ; var resultDisplay = document.getElementById ("resultRow"); var exampleDisplay = document.getElementById ("exampleRow"); var calcOutput = document.getElementById("calcOutput"); var targetTextObj = document.getElementById('targetText'); var numCompTextObj = document.getElementById('numCompText'); var compValsTextObj = document.getElementById('compValsText'); वर लक्ष्य = parseFloat (targetTextObj.value); var numComp = parseInt (numCompTextObj.value); वर compValsStr = compValsTextObj.value; वर कॉम्पवल्स = ; कॉम्पवेल्स [0] = ""; वर मैं = 0; वर एररफ्लैग = 0; // लक्ष्य मान को पार्स करने में त्रुटि अगर (isNaN (लक्ष्य)) {outputStr = "त्रुटि जांच 'लक्ष्य मान' इनपुट! 'घटकों की संख्या' इनपुट! " } // और अगर लक्ष्य या numComp में कोई त्रुटि नहीं है तो अगर (!isNaN(target) && !isNaN(numComp)) { जबकि (compValsStr.indexOf(", ") != -1) { वर अल्पविराम = compValsStr.indexOf ("", "); var newInt = parseFloat (compValsStr.substring (0, अल्पविराम)); // घटक मूल्य सूची को पार्स करने में त्रुटि, ध्वज सेट करें यदि (isNaN (newInt)) {errFlag = 1; टूटना; } compValsStr = compValsStr.substring (अल्पविराम+1, compValsStr.length); कॉम्पवेल्स = न्यूइंट; मैं++; } var newInt = parseFloat (compValsStr); // घटक मूल्य सूची को पार्स करने में त्रुटि, ध्वज सेट करें यदि (isNaN (newInt)) {errFlag = 1; } कॉम्पवल्स = newInt; if (errFlag == 0) { if (document.getElementById("resRadio").checked) { रेसिस्टर (टारगेट, numComp, compVals); } और अगर (document.getElementById("capRadio").checked) {संधारित्र (लक्ष्य, numComp, compVals); } } // घटक मूल्य सूची को पार्स करने में त्रुटि {outputStr = "त्रुटि जांच 'घटक मान सूची' इनपुट! " } } calcOutput.innerHTML = outputStr; resultDisplay.style.display = "ब्लॉक"; exampleDisplay.style.display = "फ्लेक्स"; // विंडो के परिणाम के लिए नीचे स्क्रॉल करें। स्क्रॉलटो (0, exampleDisplay.scrollHeight); } /* सर्वश्रेष्ठ रेसिस्टर कॉन्फिगरेशन प्राप्त करता है और प्रिंट करता है * टारगेट - टारगेट रेजिस्टेंस वैल्यू * numComp - टारगेट वैल को प्राप्त करने के लिए उपयोग किए जाने वाले रेसिस्टर्स की कुल संख्या * कॉम्पवल्स - रेसिस्टर्स वैल्यू की एरे */ फंक्शन रेसिस्टर (टारगेट, numComp, कॉम्पवेल्स) { // प्रतिरोध मूल्यों की लंबाई var num_res = compVals.length; // सभी संभावित घटकों के माध्यम से चलाएं (var i=1; i<=numComp; i++) { var data = ; resCombination (compVals, num_res, i, 0, डेटा, लक्ष्य); } var इकाइयाँ = document.getElementById ("चयनित_यूनिट")। मान; // प्रिंट परिणाम आउटपुटस्ट्र = "निकटतम मूल्य:" + निकटतम_वैल.टूफिक्स्ड (3) + "" + यूनिट्स + ""; outputStr + = "अंतर:" + निकटतम_diff.toFixed (3) + "" + इकाइयाँ + ""; outputStr + = "प्रतिरोधक विन्यास:"; के लिए (var i=0; i<numComp; i++) { अगर (i<निकटतम लंबाई) {outputStr += "R" + i + "=" + निकटतम + "" + इकाइयां + ""; अगर (i+1<निकटतम लंबाई) { अगर (ser_par_config[i+1]) outputStr += "||"; अन्य आउटपुटस्ट्र + = "+"; } } और ब्रेक; } } /* लक्ष्य मान प्राप्त करने के लिए प्रतिरोधों के सर्वोत्तम संयोजन की गणना करता है। * रेस - प्रतिरोधी मानों की इनपुट सरणी * num_res - प्रतिरोधी मानों की इनपुट सरणी का आकार * num_comb - अनुमत प्रतिरोधकों की संख्या * अनुक्रमणिका - कंघी का सूचकांक * कंघी - वर्तमान संयोजन की सरणी * लक्ष्य - लक्ष्य मान * कोई वापसी मूल्य नहीं - वैश्विक मूल्यों के लिए वर्तमान सर्वोत्तम संयोजन पास करता है * / फ़ंक्शन resCombination (res, num_res, num_comb, अनुक्रमणिका, कंघी, लक्ष्य) {// वर्तमान संयोजन पूरा हो गया है अगर (सूचकांक == num_comb) { var ser_par_size = Math.pow (2, num_comb); // 2^(घटकों की संख्या) var ser_par = ; // बूल सरणी प्रत्येक घटक var कैल्क के लिए सीरियल या समानांतर निर्दिष्ट करती है; // परिकलित समतुल्य प्रतिरोध मान // हर संभव श्रृंखला के माध्यम से कदम/वर्तमान संयोजन के समानांतर विन्यास (var j=0; j.) के) और 1; } // (var k=0; k<num_comb; k++) {// पहले नंबर के लिए श्रृंखला/समानांतर कॉम्बो के आधार पर संयोजन के लिए गणना करें, बस अगर (k==0) कैल्क = कंघी [k] जोड़ें; // शून्य का अर्थ है श्रृंखला, प्रतिरोध मान जोड़ें अन्यथा यदि (!ser_par[k]) कैल्क += कंघी [k]; // एक का अर्थ है समानांतर, व्युत्क्रम के योग का व्युत्क्रम यदि (ser_par[k]) कैल्क = (calc*comb[k])/(calc+comb[k]); } // यह देखने के लिए जांचें कि क्या अंतर पिछले सबसे अच्छे से कम है अगर (Math.abs(calc - target) <निकटतम_diff) {// यह कम है, इसलिए वैश्विक मानों को निकटतम_वल = कैल्क अपडेट करें; निकटतम_diff = Math.abs (कैल्क - लक्ष्य); // शून्य के लिए स्पष्ट (var k=0; k<num_comb; k++) {निकटतम[k] = 0; } // (var k=0; k<num_comb; k++) {निकटतम[k] = कंघी[k]; ser_par_config [k] = ser_par [k]; } } } वापसी 0; } // पुनरावर्ती रूप से कॉल करें और इंडेक्स को सभी संभावित मानों के साथ बदलें (var i=0; i= num_comb-index; i++) {comb[index] = res; resCombination (res, num_res, num_comb, अनुक्रमणिका+1, कंघी, लक्ष्य); } } /* सर्वोत्तम कैपेसिटर कॉन्फ़िगरेशन को पुनः प्राप्त और प्रिंट करता है * लक्ष्य - लक्ष्य कैपेसिटेंस मान * numComp - लक्ष्य वैल प्राप्त करने के लिए उपयोग किए जाने वाले कैपेसिटर्स की कुल संख्या * कॉम्पवल्स - कैपेसिटर वैल्यू की सरणी * / फ़ंक्शन कैपेसिटर (लक्ष्य, numComp, कॉम्पवेल्स) {// कैपेसिटेंस मानों की लंबाई var num_cap = compVals.length; // सभी संभावित घटकों के माध्यम से चलाएं (var i=1; i<=numComp; i++) { var data = ; capCombination (compVals, num_cap, i, 0, डेटा, लक्ष्य); } var इकाइयाँ = document.getElementById ("चयनित_यूनिट")। मान; // प्रिंट परिणाम आउटपुटस्ट्र = "निकटतम मूल्य:" + निकटतम_वैल.टूफिक्स्ड (3) + "" + यूनिट्स + ""; outputStr + = "अंतर:" + निकटतम_diff.toFixed (3) + "" + इकाइयाँ + ""; outputStr + = "संधारित्र विन्यास:"; के लिए (var i=0; i<numComp; i++) { अगर (i<निकटतम लंबाई) {outputStr += "C" + i + "=" + निकटतम + "" + इकाइयां + ""; अगर (i+1<निकटतम लंबाई) { if (ser_par_config[i+1]) outputStr += "||"; अन्य आउटपुटस्ट्र + = "+"; } } और ब्रेक; } } /* लक्ष्य मान प्राप्त करने के लिए कैपेसिटर के सर्वोत्तम संयोजन की गणना करता है। * टोपी - संधारित्र मूल्यों की इनपुट सरणी * num_cap - संधारित्र मूल्यों के इनपुट सरणी का आकार * num_comb - संधारित्रों की संख्या की अनुमति है * सूचकांक - कंघी का सूचकांक * कंघी - वर्तमान संयोजन की सरणी * लक्ष्य - लक्ष्य मूल्य * कोई वापसी मूल्य नहीं - वैश्विक मूल्यों के लिए वर्तमान सर्वोत्तम संयोजन पास करता है */ फ़ंक्शन कैप कॉम्बिनेशन (कैप, num_cap, num_comb, अनुक्रमणिका, कंघी, लक्ष्य) {// वर्तमान संयोजन पूरा हो गया है यदि (इंडेक्स == num_comb) { var ser_par_size = Math.pow (2, num_comb); // 2^(घटकों की संख्या) var ser_par = ; // बूल सरणी प्रत्येक घटक var कैल्क के लिए सीरियल या समानांतर निर्दिष्ट करती है; // परिकलित समतुल्य समाई मान // हर संभव श्रृंखला के माध्यम से कदम/वर्तमान संयोजन के समानांतर विन्यास (var j=0; j) के) और 1; } // के लिए श्रृंखला/समानांतर कॉम्बो के आधार पर संयोजन के लिए गणना करें (var k=0; k