როგორ მივაღწიოთ ნებისმიერ წინააღმდეგობას/ტევადობას უკვე არსებული კომპონენტების გამოყენებით!: 6 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:15

ეს არ არის მხოლოდ სხვა სერიის/პარალელური ეკვივალენტური წინააღმდეგობის გამომთვლელი! ეს პროგრამა ითვლის, თუ როგორ უნდა დააკავშიროთ რეზისტორებს/კონდენსატორებს, რომლებიც თქვენ გაქვთ, რათა მიაღწიოთ მიზნობრივი წინააღმდეგობის/ტევადობის მნიშვნელობას, რაც გჭირდებათ.

ოდესმე დაგჭირდათ კონკრეტული რეზისტორი ან კონდენსატორი, რომელიც არ გაქვთ ან არ არსებობს? ნუ გეშინია! თქვენ ალბათ შეგიძლიათ გააკეთოთ ეს კონკრეტული წინააღმდეგობა ან ტევადობის მნიშვნელობა უკვე არსებული კომპონენტების გამოყენებით. მილიონობით სხვადასხვა კომბინაციით უზარმაზარი მრავალფუნქციური ოპტიმიზაციის პრობლემის გადაჭრის ნაცვლად, გამოიყენეთ ეს პროგრამა!

უბრალოდ შეარჩიეთ რეზისტორი ან კონდენსატორი, შეიყვანეთ სამიზნე მნიშვნელობა, შეიყვანეთ კომპონენტების მაქსიმალური რაოდენობა, რომელთა გამოყენება გსურთ, შეიყვანეთ თქვენი კომპონენტების მნიშვნელობების სია და დააჭირეთ გამოთვლას! პროგრამა დააფურთხებს რა კომპონენტები გამოიყენოს და როგორ დააკავშიროს ისინი მიზნობრივი მნიშვნელობის მისაღწევად.

კალკულატორის გამოსაცდელად ეწვიეთ ამ ვებ პროგრამას.

წყაროს კოდის სანახავად ეწვიეთ ამ Github საცავს.

გთხოვთ შემატყობინოთ თუ გაქვთ რაიმე შემოთავაზება ამ დიზაინის ინსტრუმენტის გამოყენებადობის კიდევ უფრო გასაუმჯობესებლად!

ნაბიჯი 1: ფონი

ეს ვებ პროგრამა შემუშავდა აუცილებლობის გამო. არსებობს მრავალი განსხვავებული სქემა, რომელსაც მე ვაშენებ და მოითხოვს სპეციფიკურ რეზისტორს ან კონდენსატორს. ბევრჯერ, მე არ მაქვს რეზისტორი ან კონდენსატორი ამ კონკრეტული მნიშვნელობით. ზოგჯერ ისინი არ ქმნიან კომპონენტს იმ უნიკალური ღირებულებით! იმის ნაცვლად, რომ თავი დავანებო ან დავთანხმდე იმაზე, რაც იდეალურზე ნაკლებია, მე გადავწყვიტე დავწერო პროგრამა, რომელიც გადახედა რეზისტორების ყველა შესაძლო კომბინაციას (ყველა შესაძლო მნიშვნელობას და იქნება ეს სერიული თუ პარალელური) და დავუბრუნო საუკეთესო კომბინაცია.

ჩემი ორგანოსთვის სქემის შემუშავებისას, როგორც Bands Instructable Project– ის ნაწილი, მე უნდა შევეცადე ხელით გამოვთვალო კონდენსატორების საუკეთესო კომბინაცია კონკრეტული სიხშირის მისაღწევად. ეს პროცესი წარმოუდგენლად დამღლელი იყო და მე საბოლოოდ უბრალოდ დავანებე თავი და წავედი კონდენსატორის კომბინაციებით, რომლებიც წარმოშობდნენ ნებისმიერი რაოდენობის მოსმენილ სიხშირეს. ახლა ამ ვებ აპლიკაციის საშუალებით შემიძლია ჩემი ორგანო შევადგინო კონკრეტული სიხშირისთვის და დავაკორექტირო ის კლავიატურის ნოტებზე! ქვემოთ მოყვანილი განტოლება გამოიყენება კონკრეტული სიხშირის გამოსათვლელად და განიხილება სხვა Instructables პროექტში.

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

ამ განტოლების გამოყენებით, სადაც R1 = 100 kOhm და R2 = 10 kOhm, მე გამოვთვალე, რომ 27.33 nF კონდენსატორი გამოიმუშავებს A4 შენიშვნას (სიხშირე 440 Hz). ჩემი პროგრამის გამოყენებით, მე შევძელი გამოვთვალო ექვივალენტური ტევადობის მნიშვნელობა.001 nF ფარგლებში (გაცილებით ნაკლები ვიდრე ტოლერანტობა სტანდარტულ კონდენსატორზე), რომელიც შემიძლია შევქმნა კონდენსატორების გამოყენებით, რომლებიც მე უკვე მქონდა გარშემო. შედეგად გამომავალი და კონფიგურაცია აღწერილია ქვემოთ. ახლა მე შემიძლია ბევრად უფრო ეფექტურად და ეფექტურად მოვახდინო ჩემი ორგანოს სტანდარტული ნოტების ზუსტი სიხშირეები. ვისურვებდი რომ ეს თავიდანვე გამეკეთებინა. ჩემი დემო სიმღერა ორგანზე ალბათ ბევრად უკეთ ჟღერდა.

უახლოესი მნიშვნელობა: 27.329 nF სხვაობა: 0.001 nFC კონდენსატორი კონფიგურაცია: C0 = 0.068 nF || C1 = 30 nF + C2 = 300 nF

რეზისტორ კონდენსატორის ეკვივალენტობის განტოლებები

ცნობისთვის, ქვემოთ მოცემულია ეკვივალენტობის განტოლებები წრეში რეზისტორებისა და კონდენსატორების გაერთიანებისათვის.

• სერიის რეზისტორები (R1 + R2): Req = R1 + R2
• რეზისტორები პარალელურად (R1 || R2): Req = 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 Ohms + R1 = 470 Ohms || R2 = 3300 Ohms + R3 = 15000 Ohms

თუ დაიცავთ ზემოთ განხილულ მითითებებს, ხედავთ, რომ ეს ექვივალენტია ზემოთ განტოლებისა და სურათის ზემოთ.

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

ნაბიჯი 5: მეტი პროექტი

მეტი პროექტისთვის ეწვიეთ ჩემს გვერდებს:

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

ნაბიჯი 6: წყაროს კოდი

წყაროს კოდის სანახავად ეწვიეთ ამ Github საცავს ან იხილეთ ქვემოთ JavaScript.

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

/* r/c კალკულატორი სკრიპტირება*//* ------------------------------------------ -------------------------*/ var closeest_val; // უახლოესი მნიშვნელობა აქამდე var closeest_diff = 1000000.00; // განსხვავება val და target var უახლოესი = ; // მასივის დეტალების მნიშვნელობების კომპონენტები var ser_par_config = ; // მასივი დეტალური სერიული/პარალელური var outputStr = ""; ფუნქცია calculatorClick () {// გაასუფთავეთ გლობალური მნიშვნელობები ყოველი ახალი დაწკაპუნებისთვის closeest_val = 0; უახლოესი_დიფ = 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'); var target = parseFloat (targetTextObj.value); var numComp = parseInt (numCompTextObj.value); var compValsStr = compValsTextObj.value; var compVals = ; compVals [0] = ""; var i = 0; var errFlag = 0; // შეცდომა სამიზნე მნიშვნელობის გაანალიზებაში, თუ (isNaN (სამიზნე)) {outputStr = "შეცდომა შემოწმებულია" სამიზნე მნიშვნელობის "შეყვანა!"} // შეცდომა სხვა კომპონენტების ანალიზისას, თუ (isNaN (numComp)) {outputStr = "შეცდომის შემოწმება 'კომპონენტების შეყვანის რაოდენობა! "} // სხვაგვარად, თუ არ არის შეცდომა სამიზნეში ან numComp სხვა შემთხვევაში თუ (! IsNaN (სამიზნე) &&! IsNaN (numComp)) {while (compValsStr.indexOf (", ")! = -1) {var მძიმით = compValsStr.indexOf (","); var newInt = parseFloat (compValsStr.substring (0, მძიმე)); // შეცდომა კომპონენტების სიის ანალიზისას, დროშის დაყენება if (isNaN (newInt)) {errFlag = 1; შესვენება; } compValsStr = compValsStr.substring (მძიმით+1, compValsStr.length); compVals = newInt; მე ++; } var newInt = parseFloat (compValsStr); // შეცდომა კომპონენტების სიის ანალიზისას, დროშის დაყენება if (isNaN (newInt)) {errFlag = 1; } compVals = newInt; if (errFlag == 0) {if (document.getElementById ("resRadio"). შემოწმებულია) {resistor (target, numComp, compVals); } else if (document.getElementById ("capRadio"). შემოწმებულია) {capacitor (target, numComp, compVals); }} // შეცდომა კომპონენტის ღირებულებების ჩამონათვალის სხვა ნაწილში {outputStr = "შეცდომა" კომპონენტის ღირებულებების სიის შემოწმება! "}} calcOutput.innerHTML = outputStr; resultDisplay.style.display = "დაბლოკვა"; exampleDisplay.style.display = "მოქნილი"; // გადაახვიეთ ქვემოთ შედეგამდე window.scrollTo (0, exampleDisplay.scrollHeight); } / * იღებს და ბეჭდავს საუკეთესო რეზისტორის კონფიგურაციას * სამიზნე - სამიზნე წინააღმდეგობის მნიშვნელობა * რიცხვი კომპ // წინააღმდეგობის მნიშვნელობების სიგრძე var num_res = compVals.length; // გაუშვით კომპონენტების ყველა შესაძლო რაოდენობა (var i = 1; i <= numComp; i ++) {var data = ; resCombination (compVals, num_res, i, 0, data, target); } var ერთეული = document.getElementById ("შერჩეული_ ერთეული") მნიშვნელობა; // შედეგების ამობეჭდვა outputStr = "Closest Value:" + closeest_val.to დაფიქსირდა (3) + "" + ერთეული + ""; outputStr + = "სხვაობა:" + უახლოესი_დიფ. დაფიქსირებული (3) + "" + ერთეულები + ""; outputStr += "რეზისტორის კონფიგურაცია:"; for (var i = 0; i <numComp; i ++) {if (i <close.length) {outputStr + = "R" + i + "=" + უახლოესი + "" + ერთეულები + ""; if (i+1 <უახლოესი. სიგრძე) {if (ser_par_config [i+1]) outputStr+= "||"; else outputStr + = " +"; }} სხვაგან შესვენება; }} /* ითვლის რეზისტორების საუკეთესო კომბინაციას მიზნობრივი მნიშვნელობის მისაღწევად. * res - რეზისტორული მნიშვნელობების მასივი * num_res - რეზისტორების მნიშვნელობების მასივის შეყვანის ზომა * num_comb - დასაშვები რეზისტორების რაოდენობა * ინდექსი - სავარცხლის ინდექსი * სავარცხელი - მიმდინარე კომბინაციის მასივი * სამიზნე - სამიზნე მნიშვნელობა * დაბრუნების მნიშვნელობა - გადასცემს მიმდინარე საუკეთესო კომბინაციას გლობალურ მნიშვნელობებზე */ ფუნქცია resCombination (res, num_res, num_comb, index, comb, target) {// მიმდინარე კომბინაცია დასრულებულია თუ (ინდექსი == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2^(კომპონენტების რაოდენობა) var ser_par = ; // bool მასივი, რომელიც განსაზღვრავს სერიულ ან პარალელურ თითოეულ კომპონენტს var calc; // გაანგარიშებული ეკვივალენტური წინააღმდეგობის მნიშვნელობა // გადადგით მიმდინარე კომბინაციის ყველა შესაძლო სერია/პარალელური კონფიგურაცია (var j = 0; j ლ) და 1; } // გააკეთეთ გამოთვლები კომბინაციისთვის სერიის/პარალელური კომბინაციისთვის (var k = 0; k <num_comb; k ++) {// პირველი რიცხვი, უბრალოდ დაამატეთ if (k == 0) calc = სავარცხელი [k]; // ნული ნიშნავს სერიას, დაამატეთ წინააღმდეგობის მნიშვნელობები სხვაგვარად თუ (! ser_par [k]) calc += comb [k]; // ერთი ნიშნავს პარალელურს, პირიქით ჯამი უკუ სხვას თუ (ser_par [k]) calc = (calc*comb [k])/(calc+comb [k]); } // შეამოწმეთ, არის თუ არა სხვაობა წინაზე უკეთესი (Math.abs (calc - target) <close_diff) {// ის ნაკლებია, ასე რომ განაახლოთ გლობალური მნიშვნელობები closeest_val = calc; უახლოესი_დიფი = 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, index+1, comb, target); }} / * ამოიღებს და ბეჭდავს კონდენსატორის საუკეთესო კონფიგურაციას * სამიზნე - მიზნობრივი ტევადობის მნიშვნელობა * რიცხვი კომპ - კონდენსატორების მთლიანი რაოდენობა, რომლის გამოყენებაც შესაძლებელი იქნება მიზნის მისაღწევად * compVals - კონდენსატორის მნიშვნელობების მასივი * / ფუნქციის კონდენსატორი (სამიზნე, numComp, compVals) {// ტევადობის მნიშვნელობების სიგრძე var num_cap = compVals.length; // გაუშვით კომპონენტების ყველა შესაძლო რაოდენობა (var i = 1; i <= numComp; i ++) {var data = ; capCombination (compVals, num_cap, i, 0, მონაცემები, სამიზნე); } var ერთეული = document.getElementById ("შერჩეული_ ერთეული") მნიშვნელობა; // შედეგების ამობეჭდვა outputStr = "Closest Value:" + closeest_val.to ფიქსირებული (3) + "" + ერთეული + ""; outputStr + = "სხვაობა:" + უახლოესი_დიფ. დაფიქსირებული (3) + "" + ერთეულები + ""; outputStr += "კონდენსატორის კონფიგურაცია:"; for (var i = 0; i <numComp; i ++) {if (i <close.length) {outputStr + = "C" + i + "=" + უახლოესი + "" + ერთეულები + ""; if (i+1 <უახლოესი. სიგრძე) {if (ser_par_config [i+1]) outputStr+= "||"; else outputStr + = " +"; }} სხვაგან შესვენება; }} /* ითვლის კონდენსატორების საუკეთესო კომბინაციას მიზნობრივი მნიშვნელობის მისაღწევად. * cap - კონდენსატორის მნიშვნელობების მასივი * num_cap - კონდენსატორის მნიშვნელობების მასივის ზომა * num_comb - დასაშვები კონდენსატორების რაოდენობა * ინდექსი - სავარცხლის ინდექსი * სავარცხელი - მიმდინარე კომბინაციის მასივი * სამიზნე - სამიზნე მნიშვნელობა * დაბრუნების მნიშვნელობა - გადასცემს მიმდინარე საუკეთესო კომბინაციას გლობალურ მნიშვნელობებზე */ ფუნქცია cap კომბინაცია (ქუდი, num_cap, num_comb, ინდექსი, სავარცხელი, სამიზნე) {// მიმდინარე კომბინაცია დასრულებულია, თუ (ინდექსი == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2^(კომპონენტების რაოდენობა) var ser_par = ; // bool მასივი, რომელიც განსაზღვრავს სერიულ ან პარალელურ თითოეულ კომპონენტს var calc; // გამოითვლება ეკვივალენტური ტევადობის მნიშვნელობა // გადადით ყველა შესაძლო სერიაზე/მიმდინარე კომბინაციის პარალელური კონფიგურაცია (var j = 0; j ლ) და 1; } // გააკეთეთ გამოთვლები კომბინაციისთვის სერიის/პარალელური კომბინაციის საფუძველზე (var k = 0; k