Paano Makamit ang Anumang Paglaban / Kapasidad Gamit ang Mga Sangkap na Mayroon Ka Na !: 6 Mga Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:09

Hindi lamang ito isa pang serye / parallel na katumbas na calculator ng paglaban! Kinakalkula ng program na ito kung paano pagsamahin ang mga resistors / capacitor na kasalukuyang mayroon ka upang makamit ang isang target na halaga ng paglaban / capacitance na kailangan mo.

Kailangan mo ba ng isang tukoy na risistor o capacitor na wala ka o wala? Huwag matakot! Marahil ay maaari mong gawin ang tukoy na halaga ng paglaban o capacitance na gumagamit ng mga sangkap na mayroon ka na. Sa halip na malutas ang isang malaking problema sa pag-optimize na may milyon-milyong iba't ibang mga kumbinasyon, gamitin ang program na ito!

Piliin lamang ang risistor o kapasitor, ipasok ang target na halaga, i-input ang max na bilang ng mga bahagi na nais mong gamitin, ipasok ang isang listahan ng mga halaga ng mga bahagi na mayroon ka, at i-click ang kalkulahin! Luluwa ng programa kung anong mga sangkap ang gagamitin at kung paano ikonekta ang mga ito upang makamit ang iyong target na halaga.

Upang subukan ang calculator, bisitahin ang web application na ito.

Upang matingnan ang source code, bisitahin ang repository ng Github na ito.

Mangyaring ipaalam sa akin kung mayroon kang anumang mga mungkahi upang higit pang mapagbuti ang kakayahang magamit ng tool na ito sa disenyo!

Hakbang 1: Background

Ang web application na ito ay nabuo nang hindi kinakailangan. Maraming iba't ibang mga circuit na binubuo ko na humihiling ng isang tiyak na risistor o capacitor. Maraming beses, wala akong risistor o kapasitor na may tiyak na halagang iyon. Minsan hindi rin sila gumagawa ng isang bahagi na may natatanging halaga! Sa halip na sumuko o mag-ayos para sa isang bagay na mas mababa sa perpekto, nagpasya akong magsulat ng isang programa upang tingnan ang bawat posibleng kumbinasyon ng mga resistor (bawat posibleng halaga at kung sila ay serye o parallel) at ibalik ang pinakamagandang kumbinasyon.

Kapag ang pagdidisenyo ng circuit para sa aking organ bilang bahagi ng aking Battle of the Bands Instructable Project, kinailangan kong subukang kalkulahin ang pinakamahusay na kumbinasyon ng mga capacitor upang makamit ang isang tukoy na dalas. Ang prosesong ito ay hindi kapani-paniwalang nakakapagod at kalaunan ay sumuko na lamang ako at sumama sa mga kumbinasyon ng capacitor na gumawa ng anumang dami ng naririnig na dalas. Ngayon sa web application na ito, maaari kong idisenyo ang aking organ para sa isang tukoy na dalas at ibagay ito sa mga tala sa isang keyboard! Ang equation sa ibaba ay ginagamit upang makalkula ang tiyak na dalas at tinalakay sa iba pang proyekto ng Instructables.

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

Gamit ang equation na ito kung saan R1 = 100 kOhm at R2 = 10 kOhm, kinakalkula ko na ang isang 27.33 nF capacitor ay gagawa ng isang A4 note (dalas 440 Hz). Gamit ang aking programa, nakalkula ko ang isang katumbas na halaga ng capacitance sa loob ng.001 nF (mas mababa kaysa sa pagpapaubaya sa isang karaniwang kapasitor) na makakalikha ako gamit ang mga capacitor na mayroon na akong nakahiga. Ang nagresultang output at pagsasaayos ay inilarawan sa ibaba. Nagagawa ko ngayon na mas mahusay at mabisang ibagay ang aking organ sa eksaktong mga frequency ng karaniwang mga tala. Nais kong nagawa ko ito upang magsimula sa. Ang aking demo song sa organ ay marahil ay may tunog ng mas mahusay.

Pinakamalapit na Halaga: 27.329 nF Pagkakaiba: 0.001 nFCapacitor Configuration: C0 = 0.068 nF || C1 = 30 nF + C2 = 300 nF

Mga Parehas na Katumbas ng Resistor Capacitor

Para sa sanggunian, sa ibaba ay ang mga katumbas na equation para sa pagsasama ng mga resistors at capacitor sa isang circuit.

• Ang mga resistor sa serye (R1 + R2): Req = R1 + R2
• Ang mga resistor ay kahanay (R1 || R2): Req = 1 / (1 / R1 + 1 / R2)
• Mga capacitor sa serye (C1 + C2): Ceq = 1 / (1 / C1 + 1 / C2)
• Mga capacitor nang kahanay (C1 || C2): Ceq = C1 + C2

Hakbang 2: Mga input

Mayroong 4 na mga input na kakailanganin mong ibigay:

1. Kung kinakalkula mo ang isang halaga para sa isang risistor o isang kapasitor.
2. Ang target na paglaban o halaga ng capacitance at ang mga yunit.
3. Ang maximum na bilang ng mga bahagi na nais mong gamitin upang makamit ang target na halaga (ibig sabihin, hindi ko nais na gumamit ng higit sa 3 resistors upang makamit ang aking target na halaga ng paglaban).
4. Ang listahan ng mga halaga para sa mga resistors / capacitor na kasalukuyang mayroon ka. Ang mga halagang ito ay dapat na nasa parehong mga yunit ng iyong target na halaga (ibig sabihin kung ang iyong target na halaga ay 110 nF, ang lahat ng iyong mga halagang dapat ibigay sa nF).

Hakbang 3: Resulta

Makakakuha ka ng 3 output para sa iyong resulta:

1. Pinakamalapit na Halaga - ang pinakamalapit na halaga ng paglaban / capacitance na nakamit mo sa iyong mga parameter.
2. Pagkakaiba - kung gaano kalayo ang iyong pinakamalapit na halaga ay mula sa iyong target na halaga.
3. Pag-configure ng Resistor / Capacitor - isang listahan ng mga halaga ng resistors / capacitor na gagamitin at ang kanilang pagsasaayos.

Hakbang 4: Pag-unawa sa Iyong Resulta

Ang output ng pagsasaayos ay gumagamit ng isang karaniwang notasyon. "+" nangangahulugang ang mga bahagi ay nasa serye at "||" nangangahulugang ang mga sangkap ay magkapareho. Ang mga operator ay may pantay na precedence at kaliwa-sa-kanan na nauugnay nangangahulugang pinagsama-sama mo ang mga termino mula sa kaliwa at paglipat sa kanan.

Halimbawa, tingnan ang sumusunod na resulta:

Pag-configure ng Resistor: R0 = 15 Ohms + R1 = 470 Ohms || R2 = 3300 Ohms + R3 = 15000 Ohms

Kung susundin mo ang mga alituntuning tinalakay sa itaas, maaari mong makita na ito ay katumbas ng sumusunod na equation at imahe sa itaas.

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

Hakbang 5: Maraming Mga Proyekto

Para sa higit pang mga proyekto, bisitahin ang aking mga pahina:

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

Hakbang 6: Source Code

Upang matingnan ang source code, bisitahin ang repository ng Github o makita ang JavaScript sa ibaba.

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

/ * r / c calculator scripting * / / * ----------------- ----------------- * / var pinakamalapit na_val; // pinakamalapit na halaga sa ngayon var closer_diff = 1000000.00; // diff of val and target var closer = ; // array na nagdedetalye ng mga halaga ng mga sangkap var ser_par_config = ; // array detailing serial / parallel var outputStr = ""; function calculatorClick () {// limasin ang mga halagang pandaigdigan para sa bawat bagong pag-click na pinakamalapit na_val = 0; closer_diff = 1000000.00; pinakamalapit = ; ser_par_config = ; var resultDisplay = document.getElementById ("resultaRow"); 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; // error in parsing target target if (isNaN (target)) {outputStr = "Error check 'Target Value' input!"} // error sa pag-parse ng bilang ng mga sangkap kung (isNaN (numComp)) {outputStr = "Error check 'Bilang ng mga Component' input! "} // iba pa kung walang error sa target o numComp pa kung (! IsNaN (target) &&! IsNaN (numComp)) {habang (compValsStr.indexOf (", ")! = -1) {var comma = compValsStr.indexOf (","); var newInt = parseFloat (compValsStr.substring (0, kuwit)); // error sa pag-parse ng listahan ng halaga ng sangkap, itakda ang flag kung (isNaN (newInt)) {errFlag = 1; pahinga; } compValsStr = compValsStr.substring (kuwit + 1, compValsStr.length); compVals = newInt; ako ++; } var newInt = parseFloat (compValsStr); // error sa pag-parse ng listahan ng halaga ng sangkap, itakda ang flag kung (isNaN (newInt)) {errFlag = 1; } compVals = newInt; kung (errFlag == 0) {kung (document.getElementById ("resRadio"). naka-check) {resistor (target, numComp, compVals); } iba pa kung (document.getElementById ("capRadio"). naka-check) {capacitor (target, numComp, compVals); }} // error sa pag-parse ng listahan ng halaga ng sangkap na iba pa {outputStr = "Error check 'Listahan ng Mga Halaga ng Mga Halaga' na input!"}} CacOutput.innerHTML = outputStr; resultaDisplay.style.display = "block"; halimbawaDisplay.style.display = "flex"; // scroll down to result window.scrollTo (0, exampleDisplay.scrollHeight); } / * Kinukuha at naka-print ang pinakamahusay na pagsasaayos ng resistor * target - halaga ng paglaban sa target * numComp - kabuuang bilang ng mga resistor na pinapayagan na magamit upang makamit ang target na val * compVals - array ng mga halaga ng risistor * / resistor ng pag-andar (target, numComp, compVals) { // haba ng mga halaga ng paglaban var num_res = compVals.length; // patakbuhin ang lahat ng posibleng bilang ng mga bahagi para sa (var i = 1; i <= numComp; i ++) {var data = ; resCombination (compVals, num_res, i, 0, data, target); } var unit = document.getElementById ("napili_unit"). halaga; // print results outputStr = "Closest Value:" + closer_val.toFixed (3) + "" + unit + ""; outputStr + = "Pagkakaiba:" + closer_diff.toFixed (3) + "" + unit + ""; outputStr + = "Configuration ng Resistor:"; para sa (var i = 0; i <numComp; i ++) {if (i <closer.length) {outputStr + = "R" + i + "=" + pinakamalapit + "" + unit + ""; kung (i + 1 <pinakamalapit.length) {kung (ser_par_config [i + 1]) outputStr + = "||"; iba pa ang outputStr + = "+"; }} iba pa masira; }} / * Kinakalkula ang pinakamahusay na kumbinasyon ng mga resistors upang makamit ang isang target na halaga. * res - input ng mga halaga ng resistor * num_res - laki ng input ng mga halaga ng resistor * num_comb - bilang ng resistors na pinapayagan * index - index ng suklay * comb - array ng kasalukuyang kombinasyon * target - ang target na halaga * Walang halaga ng pagbalik - ipinapasa ang kasalukuyang pinakamahusay na kumbinasyon sa mga pandaigdigang halaga * / function resCombination (res, num_res, num_comb, index, comb, target) {// kumpleto ang kasalukuyang kombinasyon kung (index == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2 ^ (bilang ng mga bahagi) var ser_par = ; // bool array na tumutukoy sa serial o parallel para sa bawat bahagi ng var calc; // kinakalkula ang katumbas na halaga ng paglaban // hakbang sa bawat posibleng serye / parallel config ng kasalukuyang kombinasyon para sa (var j = 0; j k) & 1; } // gawin ang mga kalkulasyon para sa kombinasyon batay sa series / parallel combo para sa (var k = 0; k <num_comb; k ++) {// unang numero, idagdag lamang kung (k == 0) calc = comb [k]; // zero nangangahulugang serye, magdagdag ng mga halaga ng paglaban kung (! ser_par [k]) calc + = suklay [k]; // ang isa ay nangangahulugang parallel, kabaligtaran ng kabuuan ng mga kapalit kung (ser_par [k]) calc = (calc * comb [k]) / (calc + comb [k]); } // suriin upang makita kung ang pagkakaiba ay mas mababa kaysa sa dating pinakamahusay kung (Math.abs (calc - target) <closer_diff) {// mas mababa ito, kaya i-update ang mga halagang pandaigdigan na pinakamalapit_val = calcul; closer_diff = Math.abs (calcul - target); // clear to zero for (var k = 0; k <num_comb; k ++) {pinakamalapit [k] = 0; } // update pinakamalapit na halaga at mga serye / parallel arrays para sa (var k = 0; k <num_comb; k ++) {pinakamalapit [k] = suklay [k]; ser_par_config [k] = ser_par [k]; }}} ibalik ang 0; } // recursively call at palitan ang index ng lahat ng mga posibleng halaga para sa (var i = 0; i = num_comb-index; i ++) {comb [index] = res ; resCombination (res, num_res, num_comb, index + 1, suklay, target); }} / * Kinukuha at naka-print ang pinakamahusay na pagsasaayos ng capacitor * target - halaga ng target na capacitance * numComp - kabuuang bilang ng mga capacitor na pinapayagan na magamit upang makamit ang target na val * compVals - array ng mga halaga ng capacitor * / function capacitor (target, numComp, compVals) {// haba ng mga halaga ng capacitance var num_cap = compVals.length; // patakbuhin ang lahat ng posibleng bilang ng mga bahagi para sa (var i = 1; i <= numComp; i ++) {var data = ; capCombination (compVals, num_cap, i, 0, data, target); } var unit = document.getElementById ("napili_unit"). halaga; // print results outputStr = "Closest Value:" + closer_val.toFixed (3) + "" + unit + ""; outputStr + = "Pagkakaiba:" + closer_diff.toFixed (3) + "" + unit + ""; outputStr + = "Configuration ng Capacitor:"; para sa (var i = 0; i <numComp; i ++) {if (i <closer.length) {outputStr + = "C" + i + "=" + pinakamalapit + "" + unit + ""; kung (i + 1 <pinakamalapit.length) {kung (ser_par_config [i + 1]) outputStr + = "||"; iba pa ang outputStr + = "+"; }} iba pa masira; }} / * Kinakalkula ang pinakamahusay na kumbinasyon ng mga capacitor upang makamit ang isang target na halaga. * cap - input array ng mga halaga ng capacitor * num_cap - laki ng input ng mga halaga ng capacitor * num_comb - bilang ng pinapayagan na mga capacitor * index - index ng suklay * comb - array ng kasalukuyang kombinasyon * target - ang target na halaga * Walang halaga ng pagbalik - ipinapasa ang kasalukuyang pinakamahusay na kumbinasyon sa mga pandaigdigang halaga * / function capCombination (cap, num_cap, num_comb, index, comb, target) {// kumpleto ang kasalukuyang kombinasyon kung (index == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2 ^ (bilang ng mga bahagi) var ser_par = ; // bool array na tumutukoy sa serial o parallel para sa bawat bahagi ng var calc; // kinakalkula ang katumbas na halaga ng capacitance // hakbang sa bawat posibleng serye / parallel config ng kasalukuyang kombinasyon para sa (var j = 0; j k) & 1; } // gawin ang mga kalkulasyon para sa kombinasyon batay sa serye / parallel combo para sa (var k = 0; k