Kako doseči kakršen koli odpor/zmogljivost z uporabo komponent, ki jih že imate!: 6 korakov

2024 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2024-01-30 12:02

To ni samo še en kalkulator serije/vzporednega ekvivalentnega upora! Ta program izračuna, kako združiti upore/kondenzatorje, ki jih trenutno potrebujete, da dosežete ciljno vrednost upora/kapacitivnosti, ki jo potrebujete.

Ste kdaj potrebovali poseben upor ali kondenzator, ki ga nimate ali ne obstaja? Ne bojte se! To specifično vrednost upora ali kapacitivnosti lahko verjetno naredite z uporabo komponent, ki jih že imate. Namesto da bi z milijoni različnih kombinacij rešili ogromen več variabilni optimizacijski problem, uporabite ta program!

Samo izberite upor ali kondenzator, vnesite ciljno vrednost, vnesite največje število komponent, ki jih želite uporabiti, vnesite seznam vrednosti komponent, ki jih imate, in kliknite izračunaj! Program bo izpljunil, katere komponente uporabiti in kako jih povezati, da dosežete ciljno vrednost.

Če želite preizkusiti kalkulator, obiščite to spletno aplikacijo.

Če si želite ogledati izvorno kodo, obiščite to skladišče Github.

Sporočite mi, če imate kakšne predloge za dodatno izboljšanje uporabnosti tega orodja za oblikovanje!

1. korak: Ozadje

Ta spletna aplikacija je bila razvita iz nuje. Konstruiram veliko različnih vezij, ki zahtevajo zelo specifičen upor ali kondenzator. Velikokrat nimam upora ali kondenzatorja s to posebno vrednostjo. Včasih niti ne naredijo komponente s to edinstveno vrednostjo! Namesto da bi se odrekel ali se odločil za nekaj, kar ni idealno, sem se odločil, da napišem program, ki bo pregledal vsako možno kombinacijo uporov (vsako možno vrednost in ne glede na to, ali sta zaporedno ali vzporedno) in vrnil najboljšo kombinacijo.

Pri načrtovanju vezja za moje orgle v okviru mojega projekta Battle of the Bands Instructable Project sem moral poskusiti ročno izračunati najboljšo kombinacijo kondenzatorjev za dosego določene frekvence. Ta proces je bil neverjetno dolgočasen in na koncu sem le obupal in uporabil kombinacije kondenzatorjev, ki so proizvedle poljubno količino zvočne frekvence. S to spletno aplikacijo lahko svoje orgle oblikujem za določeno frekvenco in jih prilagodim zapisom na tipkovnici! Spodnja enačba se uporablja za izračun posebne frekvence in je obravnavana v drugem projektu Instructables.

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

Z uporabo te enačbe, kjer je R1 = 100 kOhm in R2 = 10 kOhm, sem izračunal, da bo kondenzator 27,33 nF ustvaril noto A4 (frekvenca 440 Hz). S svojim programom sem lahko izračunal ekvivalentno vrednost kapacitivnosti znotraj 0,001 nF (veliko manj kot toleranca na standardnem kondenzatorju), ki jo lahko ustvarim s kondenzatorji, ki sem jih že imel. Rezultat in konfiguracija sta opisana spodaj. Zdaj lahko veliko bolj učinkovito in učinkovito uglašim svoje orglice na natančne frekvence standardnih not. Želim si, da bi to storil za začetek. Moja demo pesem na orglah bi verjetno zvenela veliko bolje.

Najbližja vrednost: 27,329 nF Razlika: 0,001 nFC Konfiguracija kondenzatorja: C0 = 0,068 nF || C1 = 30 nF + C2 = 300 nF

Enačbe enakovrednosti upornih kondenzatorjev

Za referenco so spodaj enačbe enakovrednosti za združevanje uporov in kondenzatorjev v vezju.

• Serijski upori (R1 + R2): Req = R1 + R2
• Vzporedni upori (R1 || R2): Req = 1/(1/R1 + 1/R2)
• Kondenzatorji v seriji (C1 + C2): Ceq = 1/(1/C1 + 1/C2)
• Kondenzatorji vzporedno (C1 || C2): Ceq = C1 + C2

2. korak: Vhodi

Vnesti morate 4 vložke:

1. Ali izračunate vrednost za upor ali kondenzator.
2. Vrednost ciljnega upora ali kapacitivnosti in enote.
3. Največje število komponent, ki bi jih radi uporabili za dosego ciljne vrednosti (tj. Ne bi rad uporabil več kot 3 uporov za dosego ciljne vrednosti upora).
4. Seznam vrednosti uporov/kondenzatorjev, ki jih trenutno imate. Te vrednosti bi morale biti v istih enotah kot ciljna vrednost (tj. Če je bila vaša ciljna vrednost 110 nF, bi morale biti vse vaše vrednosti podane v nF).

3. korak: Rezultat

Za rezultat boste dobili 3 izhode:

1. Najbližja vrednost - najbližja vrednost upora/kapacitivnosti, ki ste jo lahko dosegli s svojimi parametri.
2. Razlika - kako daleč je bila vaša najbližja vrednost od vaše ciljne vrednosti.
3. Konfiguracija upora/kondenzatorja - seznam vrednosti uporov/kondenzatorjev za uporabo in njihova konfiguracija.

4. korak: Razumevanje rezultata

Konfiguracijski izhod uporablja standardni zapis. "+" pomeni, da so komponente zaporedno in "||" pomeni, da so komponente vzporedne. Operaterji imajo enako prednost in so asociativni od leve proti desni, kar pomeni, da združujete izraze skupaj od leve do desne.

Na primer, poglejte naslednji rezultat:

Konfiguracija upora: R0 = 15 Ohmov + R1 = 470 Ohmov || R2 = 3300 Ohmov + R3 = 15000 Ohmov

Če sledite zgornjim smernicam, lahko vidite, da je to enakovredno naslednji enačbi in sliki zgoraj.

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

5. korak: Več projektov

Za več projektov obiščite moje strani:

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

6. korak: izvorna koda

Če si želite ogledati izvorno kodo, obiščite to skladišče Github ali si oglejte JavaScript spodaj.

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

/* skripte za kalkulator r/c*//* --------------------------------------- -------------------------*/ var najbližji_val; // najbližja vrednost doslej var najbližji_diff = 1000000,00; // razlika od val in ciljna var najbližja = ; // matrika s podrobnimi vrednostmi komponent var ser_par_config = ; // matrika, ki podrobno opisuje serijski/vzporedni var outputStr = ""; function calculatorClick () {// počisti globalne vrednosti za vsak nov klik najbližji_val = 0; najbližja_razlika = 1000000,00; najbližje = ; 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; // napaka pri razčlenjevanju ciljne vrednosti if (isNaN (target)) {outputStr = "Napaka pri preverjanju vnosa 'Target Value'!"} // napaka pri razčlenjevanju števila komponent else if (isNaN (numComp)) {outputStr = "Preverjanje napak 'Število komponent' vnos! "} // else če ni napake v cilju ali numComp else if (! IsNaN (cilj) &&! IsNaN (numComp)) {while (compValsStr.indexOf (", ")! = -1) {var vejica = compValsStr.indexOf (","); var newInt = parseFloat (compValsStr.substring (0, vejica)); // napaka pri razčlenjevanju vrednosti vrednosti komponente, zastava if (isNaN (newInt)) {errFlag = 1; zlom; } compValsStr = compValsStr.substring (vejice+1, compValsStr.length); compVals = newInt; i ++; } var newInt = parseFloat (compValsStr); // napaka pri razčlenjevanju vrednosti vrednosti komponente, zastava if (isNaN (newInt)) {errFlag = 1; } compVals = newInt; if (errFlag == 0) {if (document.getElementById ("resRadio"). označeno) {upor (target, numComp, compVals); } drugače če (document.getElementById ("capRadio"). preverjeno) {kondenzator (cilj, numComp, compVals); }} // napaka pri razčlenjevanju vrednosti vrednosti komponente else {outputStr = "Preverjanje napak 'vnos seznama vrednosti komponent'!"}} calcOutput.innerHTML = outputStr; resultDisplay.style.display = "blok"; exampleDisplay.style.display = "flex"; // pomaknite se navzdol do rezultata window.scrollTo (0, exampleDisplay.scrollHeight); } / * Pridobi in natisne najboljšo konfiguracijo upora * cilj - ciljna vrednost upora * numComp - skupno število uporov, ki jih je mogoče uporabiti za dosego ciljne vrednosti val * compVals - niz vrednosti upora * / funkcijski upor (target, numComp, compVals) { // dolžina vrednosti upora var num_res = compVals.length; // prelistajte vse možno število komponent za (var i = 1; i <= numComp; i ++) {var data = ; resCombination (compVals, num_res, i, 0, data, target); } var units = document.getElementById ("selected_unit"). vrednost; // natisni rezultate outputStr = "Najbližja vrednost:" + najbližji_val.toPopravljeno (3) + "" + enote + ""; outputStr + = "Razlika:" + najbližja_razlika.popravljeno (3) + "" + enote + ""; outputStr += "Konfiguracija upora:"; za (var i = 0; i <numComp; i ++) {if (i <najbližja dolžina) {outputStr + = "R" + i + "=" + najbližji + "" + enote + ""; if (i+1 <najbližja dolžina) {if (ser_par_config [i+1]) outputStr+= "||"; else outputStr + = " +"; }} else break; }} /* Izračuna najboljšo kombinacijo uporov za dosego ciljne vrednosti. * res - vhodni niz vrednosti upora * num_res - velikost vhodnega niza vrednosti uporov * num_comb - dovoljeno število uporov * indeks - indeks glavnika * comb - niz trenutne kombinacije * target - ciljna vrednost * Ni vrnjene vrednosti - trenutna najboljša kombinacija se prenese v globalne vrednosti */ funkcija resCombination (res, num_res, num_comb, index, comb, target) {// trenutna kombinacija je popolna, če (index == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2^(število komponent) var ser_par = ; // bool niz, ki podaja zaporedno ali vzporedno za vsako komponento var calc; // izračunana ekvivalentna vrednost upora // korak skozi vsako možno serijo/vzporedno konfiguracijo trenutne kombinacije za (var j = 0; j k) & 1; } // naredimo izračune za kombinacijo na podlagi serije/vzporedne kombinacije za (var k = 0; k <num_comb; k ++) {// prvo število, samo dodamo if (k == 0) calc = comb [k]; // nič pomeni niz, dodajte vrednosti upora else if (! ser_par [k]) calc += comb [k]; // ena pomeni vzporedno, obratno od vsote vzajemnih vrednosti else if (ser_par [k]) calc = (calc*comb [k])/(calc+comb [k]); } // preverite, če je razlika manjša od prejšnje najboljše, če je (Math.abs (calc - target) <najbližje_diff) {// manjše, zato posodobite globalne vrednosti najbližji_val = kalc; najbližji_diff = Math.abs (izračun - cilj); // počisti na nič za (var k = 0; k <število_komb; k ++) {najbližje [k] = 0; } // posodobi najbližjo vrednost & niz/vzporedne matrike za (var k = 0; k <num_comb; k ++) {najbližje [k] = glavnik [k]; ser_par_config [k] = ser_par [k]; }}} vrni 0; } // rekurzivno pokličite in zamenjajte indeks z vsemi možnimi vrednostmi za (var i = 0; i = num_comb-index; i ++) {comb [index] = res ; resCombination (res, num_res, num_comb, index+1, glavnik, cilj); }} / * Pridobi in natisne najboljšo konfiguracijo kondenzatorja * cilj - ciljna vrednost kapacitivnosti * numComp - skupno število kondenzatorjev, ki jih je mogoče uporabiti za dosego ciljnega val * compVals - niz vrednosti kondenzatorjev * / funkcijski kondenzator (target, numComp, compVals) {// dolžina vrednosti kapacitivnosti var num_cap = compVals.length; // prelistajte vse možno število komponent za (var i = 1; i <= numComp; i ++) {var data = ; capCombination (compVals, num_cap, i, 0, podatki, cilj); } var units = document.getElementById ("selected_unit"). vrednost; // natisni rezultate outputStr = "Najbližja vrednost:" + najbližji_val.toPopravljeno (3) + "" + enote + ""; outputStr + = "Razlika:" + najbližja_razlika.popravljeno (3) + "" + enote + ""; outputStr += "Konfiguracija kondenzatorja:"; za (var i = 0; i <numComp; i ++) {if (i <najbližja dolžina) {outputStr + = "C" + i + "=" + najbližje + "" + enote + ""; if (i+1 <najbližja dolžina) {if (ser_par_config [i+1]) outputStr+= "||"; else outputStr + = " +"; }} else break; }} /* Izračuna najboljšo kombinacijo kondenzatorjev za dosego ciljne vrednosti. * cap - vhodni niz vrednosti kondenzatorjev * num_cap - velikost vhodnega niza vrednosti kondenzatorjev * num_comb - dovoljeno število kondenzatorjev * indeks - indeks glavnika * comb - niz trenutne kombinacije * target - ciljna vrednost * Brez povratne vrednosti - trenutna najboljša kombinacija se prenese v globalne vrednosti */ funkcija capCombination (cap, num_cap, num_comb, index, comb, target) {// trenutna kombinacija je popolna, če (index == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2^(število komponent) var ser_par = ; // bool niz, ki podaja zaporedno ali vzporedno za vsako komponento var calc; // izračunana ekvivalentna vrednost kapacitivnosti // korak skozi vsako možno serijo/vzporedno konfiguracijo trenutne kombinacije za (var j = 0; j k) & 1; } // naredimo izračune za kombinacijo na podlagi serije/vzporedne kombinacije za (var k = 0; k