Kuidas saavutada vastupanu/mahtuvust juba olemasolevate komponentide abil!: 6 sammu

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:45

See pole lihtsalt järjekordne seeria/paralleelne ekvivalenttakistuse kalkulaator! See programm arvutab välja, kuidas ühendada takistid/kondensaatorid, mida teil praegu on vajaliku takistuse/mahtuvuse sihtväärtuse saavutamiseks.

Kas olete kunagi vajanud konkreetset takistit või kondensaatorit, mida teil pole või mida pole olemas? Ära karda! Tõenäoliselt saate selle konkreetse takistuse või mahtuvuse väärtuse luua juba olemasolevate komponentide abil. Selle asemel, et lahendada tohutu mitme muutujaga optimeerimisprobleem miljonite erinevate kombinatsioonidega, kasutage seda programmi!

Valige lihtsalt takisti või kondensaator, sisestage sihtväärtus, sisestage maksimaalne komponentide arv, mida soovite kasutada, sisestage olemasolevate komponentide väärtuste loend ja klõpsake nuppu Arvuta! Programm sülitab välja, milliseid komponente kasutada ja kuidas neid oma sihtväärtuse saavutamiseks ühendada.

Kalkulaatori proovimiseks külastage seda veebirakendust.

Lähtekoodi vaatamiseks külastage seda Githubi hoidlat.

Palun andke mulle teada, kui teil on ettepanekuid selle disainitööriista kasutatavuse edasiseks parandamiseks!

Samm: taust

See veebirakendus töötati välja vajadusest. Ma konstrueerin palju erinevaid vooluahelaid, mis nõuavad väga spetsiifilist takisti või kondensaatorit. Palju kordi pole mul selle konkreetse väärtusega takistit ega kondensaatorit. Mõnikord ei tee nad isegi selle ainulaadse väärtusega komponenti! Selle asemel, et loobuda või leppida millegagi, mis on vähem kui ideaalne, otsustasin kirjutada programmi, et vaadata kõiki võimalikke takistite kombinatsioone (kõiki võimalikke väärtusi ja seda, kas need on järjestikku või paralleelselt) ja tagastada parim kombinatsioon.

Oma oreli vooluringi projekteerides osana oma bändide lahingu juhendatavast projektist, pidin proovima konkreetse sageduse saavutamiseks käsitsi välja arvutada kondensaatorite parima kombinatsiooni. See protsess oli uskumatult tüütu ja lõpuks ma lihtsalt loobusin ja läksin kondensaatorikombinatsioonidega, mis tekitasid igasuguse kuuldava sageduse. Nüüd saan selle veebirakendusega oma oreli kindlale sagedusele kujundada ja klaviatuuri nootidele häälestada! Allolevat võrrandit kasutatakse konkreetse sageduse arvutamiseks ja seda arutatakse teises Instructables projektis.

f = 1 / (0,693 × C × (R1 + 2 × R2))

Kasutades seda võrrandit, kus R1 = 100 kOhm ja R2 = 10 kOhm, arvutasin välja, et kondensaator 27,33 nF annab A4 noodi (sagedus 440 Hz). Oma programmi kasutades suutsin arvutada ekvivalentse mahtuvuse väärtuse 0,001 nF piires (palju vähem kui standardkondensaatori tolerants), mille saan luua kondensaatorite abil, mis mul juba olid. Saadud väljundit ja konfiguratsiooni kirjeldatakse allpool. Olen nüüd võimeline palju tõhusamalt ja tõhusamalt häälestama oma orelit tavaliste nootide sagedustele. Ma soovin, et oleksin seda alustuseks teinud. Minu demolaul orelil oleks ilmselt kõlanud palju paremini.

Lähim väärtus: 27,329 nF Erinevus: 0,001 nFC kondensaatori konfiguratsioon: C0 = 0,068 nF || C1 = 30 nF + C2 = 300 nF

Takisti kondensaatori ekvivalentsivõrrandid

Allpool on toodud võrdluseks võrrandid takistite ja kondensaatorite ühendamiseks ahelas.

• Takistid järjestikku (R1 + R2): Req = R1 + R2
• Takistid paralleelselt (R1 || R2): Req = 1/(1/R1 + 1/R2)
• Seeria kondensaatorid (C1 + C2): Ceq = 1/(1/C1 + 1/C2)
• Paralleelsed kondensaatorid (C1 || C2): Ceq = C1 + C2

2. samm: sisendid

Peate esitama 4 sisendit:

1. Ükskõik, kas arvutate takisti või kondensaatori väärtust.
2. Sihttakistuse või mahtuvuse väärtus ja ühikud.
3. Komponentide maksimaalne arv, mida soovite sihtväärtuse saavutamiseks kasutada (st ma ei tahaks oma sihttakistuse väärtuse saavutamiseks kasutada rohkem kui 3 takistit).
4. Praegu olemasolevate takistite/kondensaatorite väärtuste loend. Need väärtused peaksid olema teie sihtväärtusega samades ühikutes (st kui teie sihtväärtus oli 110 nF, tuleks kõik väärtused esitada nF -is).

3. samm: tulemus

Tulemuse saamiseks saate 3 väljundit:

1. Lähim väärtus - lähim takistuse/mahtuvuse väärtus, mille suutsite oma parameetritega saavutada.
2. Erinevus - kui kaugel oli teie lähim väärtus sihtväärtusest.
3. Takisti/kondensaatori konfiguratsioon - kasutatavate takistite/kondensaatorite väärtuste loend ja nende konfiguratsioon.

4. samm: tulemuse mõistmine

Konfiguratsiooni väljund kasutab standardset märget. "+" tähendab, et komponendid on järjestikku ja "||" tähendab, et komponendid on paralleelsed. Operaatoritel on võrdne tähtsus ja nad on vasakult paremale assotsiatiivsed, st rühmitate terminid kokku, alustades vasakult ja liikudes paremale.

Vaadake näiteks järgmist tulemust:

Takisti konfiguratsioon: R0 = 15 oomi + R1 = 470 oomi || R2 = 3300 oomi + R3 = 15000 oomi

Kui järgite ülalkirjeldatud juhiseid, näete, et see on samaväärne järgmise võrrandi ja ülaltoodud pildiga.

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

Samm: rohkem projekte

Rohkemate projektide jaoks külastage minu lehti:

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

6. samm: lähtekood

Lähtekoodi vaatamiseks külastage seda Githubi hoidlat või vaadake allpool olevat JavaScripti.

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

/* r/c kalkulaatori skriptimine*//* --------------------------------------- -------------------------*/ var lähim_val; // siiani lähim väärtus var lähim_diff = 1000000,00; // diferentsiaal val ja sihtvar lähim = ; // massiiv, mis kirjeldab komponentide väärtusi var ser_par_config = ; // massiiv, mis kirjeldab järjestikku/paralleelselt var outputStr = ""; function calculatorClick () {// tühjendage iga uue kliki globaalsed väärtused lähim_val = 0; lähim_diff = 1000000,00; lähim = ; 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; // viga sihtväärtuse parsimisel, kui (isNaN (sihtmärk)) {outputStr = "Vigakontroll 'sihtväärtuse' sisend!"} // viga komponentide arvu sõelumisel muu if (isNaN (numComp)) {outputStr = "Veakontroll 'Komponentide arvu sisend! "} // else, kui sihtmärgis pole viga või numComp else if (! IsNaN (target) &&! IsNaN (numComp)) {while (compValsStr.indexOf (", ")! = -1) {varikoma = compValsStr.indexOf (","); var newInt = parseFloat (compValsStr.alamstring (0, koma)); // viga komponentide väärtuste loendi sõelumisel, määrake lipp if (isNaN (newInt)) {errFlag = 1; murda; } compValsStr = compValsStr.alamstring (koma+1, compValsStr.length); compVals = newInt; i ++; } var newInt = parseFloat (compValsStr); // viga komponentide väärtuste loendi parsimisel, määrake lipp if (isNaN (newInt)) {errFlag = 1; } compVals = newInt; if (errFlag == 0) {if (document.getElementById ("resRadio"). märgitud) {resistor (target, numComp, compVals); } else if (document.getElementById ("capRadio"). märgitud) {kondensaator (sihtmärk, numComp, compVals); }} // viga komponentide väärtuste loendi sõelumisel else {outputStr = "Veakontroll 'sisestage komponentide väärtuste loend'!"}} calcOutput.innerHTML = outputStr; resultDisplay.style.display = "blokeerida"; exampleDisplay.style.display = "painduma"; // keri alla tulemuste aknasse.scrollTo (0, exampleDisplay.scrollHeight); } / * Toob välja ja prindib parima takisti konfiguratsiooni * sihtmärk - sihttakistuse väärtus * numComp - takistite koguarv, mida on lubatud sihtväärtuse saavutamiseks kasutada * compVals - takisti väärtuste massiiv * / funktsiooni takisti (sihtmärk, numComp, compVals) { // takistuse väärtuste pikkus var num_res = compVals.length; // läbida kõik võimalikud komponendid (var i = 1; i <= numComp; i ++) {var data = ; resCombination (compVals, num_res, i, 0, data, target); } var ühikud = document.getElementById ("valitud_ühik"). väärtus; // prinditulemuste outputStr = "Lähim väärtus:" + lähim_val.toFikseeritud (3) + "" + ühikud + ""; outputStr + = "Erinevus:" + lähim_diff.toFikseeritud (3) + "" + ühikut + ""; outputStr += "Takisti konfiguratsioon:"; jaoks (var i = 0; i <numComp; i ++) {kui (i <lähim.pikkus) {outputStr + = "R" + i + "=" + lähim + "" + ühikud + ""; if (i+1 <lähim.pikkus) {if (ser_par_config [i+1]) outputStr+= "||"; else outputStr + = " +"; }} muu paus; }} /* Arvutab välja parima takistite kombinatsiooni sihtväärtuse saavutamiseks. * res - takisti väärtuste sisendmassiiv * num_res - takisti väärtuste sisendmassiivi suurus * num_comb - lubatud takistite arv * indeks - kammi indeks * kamm - praeguse kombinatsiooni massiiv * sihtmärk - sihtväärtus * Tagastusväärtust pole - edastab praeguse parima kombinatsiooni globaalsetele väärtustele */ funktsiooni resCombination (res, num_res, num_comb, index, comb, target) {// praegune kombinatsioon on täielik, kui (index == num_comb) {var ser_par_size = Math.pow (2, numbrikombinatsioon); // 2^(komponentide arv) var ser_par = ; // bool array, mis määrab iga komponendi jada- või paralleelvar var; // arvutatud ekvivalenttakistusväärtus // astuge läbi kõik võimalikud praeguse kombinatsiooni seeria-/paralleelkonfiguratsioonid (var j = 0; j k) & 1; } // teha kombinatsiooni jaoks arvutused seeria/paralleelkombo põhjal (var k = 0; k <num_comb; k ++) {// esimene number, lihtsalt lisada, kui (k == 0) calc = kamm [k]; // null tähendab seeriat, lisage takistuse väärtused else, kui (! ser_par [k]) calc += kamm [k]; // üks tähendab paralleelset, vastupidine vastastikuste summade summale muu, kui (ser_par [k]) calc = (calc*kamm [k])/(calc+kamm [k]); } // kontrollige, kas erinevus on väiksem kui eelmine parim, kui (Math.abs (calc - target) <lähim_diff) {// see on väiksem, seega värskendage globaalseid väärtusi lähim_val = calc; lähim_diff = Math.abs (calc - target); // tühjendage nulli jaoks (var k = 0; k <num_comb; k ++) {lähim [k] = 0; } // värskenda lähima väärtuse & seeria/paralleelmassiive (var k = 0; k <num_comb; k ++) {lähim [k] = kamm [k]; ser_par_config [k] = ser_par [k]; }}} tagastama 0; } // rekursiivselt kutsuda ja asendada indeks kõigi võimalike väärtustega (var i = 0; i = num_comb-index; i ++) {comb [index] = res ; resCombination (res, num_res, num_comb, indeks+1, kamm, sihtmärk); }} / * Toob välja ja prindib välja parima kondensaatori konfiguratsiooni * sihtmärk - sihtmahtuvuse väärtus * numComp - kondensaatorite koguarv, mida on lubatud sihtväärtuse saavutamiseks kasutada * compVals - kondensaatoriväärtuste massiiv * / funktsioonkondensaator (sihtmärk, numComp, compVals) {// mahtuvusväärtuste pikkus var num_cap = compVals.length; // läbida kõik võimalikud komponendid (var i = 1; i <= numComp; i ++) {var data = ; capCombination (compVals, num_cap, i, 0, data, target); } var ühikud = document.getElementById ("valitud_ühik"). väärtus; // prinditulemuste outputStr = "Lähim väärtus:" + lähim_val.toFikseeritud (3) + "" + ühikud + ""; outputStr + = "Erinevus:" + lähim_diff.toFikseeritud (3) + "" + ühikut + ""; outputStr += "Kondensaatori konfiguratsioon:"; jaoks (var i = 0; i <numComp; i ++) {kui (i <lähim.pikkus) {outputStr + = "C" + i + "=" + lähim + "" + ühikud + ""; if (i+1 <lähim.pikkus) {if (ser_par_config [i+1]) outputStr+= "||"; else outputStr + = " +"; }} muu paus; }} /* Arvutab välja parima kondensaatorite kombinatsiooni sihtväärtuse saavutamiseks. * cap - kondensaatoriväärtuste sisendmassiiv * num_cap - kondensaatoriväärtuste sisendmassiivi suurus * num_comb - lubatud kondensaatorite arv * indeks - kammi indeks * kamm - praeguse kombinatsiooni massiiv * sihtmärk - sihtväärtus * Tagastusväärtust ei ole - edastab praeguse parima kombinatsiooni globaalsetele väärtustele */ funktsiooni piirikombinatsioon (2, numbrikombinatsioon); // 2^(komponentide arv) var ser_par = ; // bool array, mis määrab iga komponendi jada- või paralleelvar var; // arvutatud ekvivalentne mahtuvusväärtus // astuge läbi kõigi võimalike jada/paralleelse konfiguratsiooni praeguse kombinatsiooni jaoks (var j = 0; j k) & 1; } // tehke kombinatsiooni jaoks arvutused seeria/paralleelkombo põhjal (var k = 0; k