Hogyan lehet elérni az ellenállást/kapacitást a már meglévő komponensek használatával !: 6 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:39

Ez nem csak egy újabb sorozat/párhuzamos egyenértékű ellenállás -számológép! Ez a program kiszámítja, hogyan kombinálhatók a jelenleg szükséges ellenállások/kondenzátorok a kívánt ellenállás/kapacitás érték eléréséhez.

Szüksége volt valaha egy speciális ellenállásra vagy kondenzátorra, amely nincs, vagy nem létezik? Ne félj! Valószínűleg megteheti azt a bizonyos ellenállást vagy kapacitást a már meglévő alkatrészek használatával. Ahelyett, hogy hatalmas, többváltozós optimalizálási problémát oldana meg millió különböző kombinációval, használja ezt a programot!

Csak válassza ki az ellenállást vagy a kondenzátort, adja meg a célértéket, adja meg a használni kívánt komponensek maximális számát, írja be az összetevők értékeinek listáját, és kattintson a számítás gombra! A program kiköpi, hogy milyen összetevőket használjon, és hogyan csatlakoztassa őket a célérték eléréséhez.

A számológép kipróbálásához keresse fel ezt a webes alkalmazást.

A forráskód megtekintéséhez keresse fel ezt a Github -lerakatot.

Kérem, tudassa velem, ha bármilyen javaslata van ezen tervezőeszköz használhatóságának további javítására!

1. lépés: Háttér

Ezt a webes alkalmazást szükségből fejlesztették ki. Sok különböző áramkört konstruálok, amelyek nagyon specifikus ellenállást vagy kondenzátort igényelnek. Sokszor nincs olyan ellenállásom vagy kondenzátorom, aminek konkrét értéke lenne. Néha nem is készítenek ilyen egyedi értékű komponenst! Ahelyett, hogy feladnám vagy megelégednék valamivel, ami nem ideális, úgy döntöttem, hogy írok egy programot, amely megvizsgálja az ellenállások minden lehetséges kombinációját (minden lehetséges értéket és azt, hogy sorban vagy párhuzamosan vannak -e), és visszaadja a legjobb kombinációt.

Amikor megterveztem az orgonám áramkörét a Battle of the Bands Instructable Project részeként, meg kellett próbálnom kézzel kiszámítani a kondenzátorok legjobb kombinációját egy adott frekvencia elérése érdekében. Ez a folyamat hihetetlenül fárasztó volt, és végül csak feladtam, és kondenzátor kombinációkkal mentem, amelyek bármilyen mennyiségű hallható frekvenciát produkáltak. Most ezzel a webalkalmazással megtervezhetem az orgonámat egy adott frekvenciára, és hangolhatom a billentyűzet hangjaira! Az alábbi egyenletet a konkrét frekvencia kiszámítására használjuk, és ezt tárgyaljuk a másik Instructables projektben.

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

Ennek az egyenletnek az alkalmazásával, ahol R1 = 100 kOhm és R2 = 10 kOhm, kiszámítottam, hogy egy 27,33 nF kondenzátor A4 -es hangot állít elő (440 Hz frekvencia). A programom segítségével kiszámíthattam egy ekvivalens kapacitás értéket.001 nF -en belül (jóval kevesebb, mint a szabványos kondenzátor tűrése), amelyet a már fekvő kondenzátorok segítségével tudok létrehozni. A kapott kimenetet és konfigurációt az alábbiakban ismertetjük. Most már sokkal hatékonyabban és eredményesebben tudom hangolni a szervemet a szabványos hangok pontos frekvenciájára. Bárcsak kezdetben ezt tettem volna. A demó dalom az orgonán valószínűleg sokkal jobban hangzott volna.

Legközelebbi érték: 27,329 nF Különbség: 0,001 nFC kondenzátor konfiguráció: C0 = 0,068 nF || C1 = 30 nF + C2 = 300 nF

Ellenállás kondenzátor egyenértékű egyenletek

Az alábbiakban referenciaként az ellenállások és kondenzátorok áramkörben való kombinálásának egyenértékűségi egyenleteit találjuk.

• Soros ellenállások (R1 + R2): Req = R1 + R2
• Ellenállások párhuzamosan (R1 || R2): Req = 1/(1/R1 + 1/R2)
• Soros kondenzátorok (C1 + C2): Ceq = 1/(1/C1 + 1/C2)
• Párhuzamos kondenzátorok (C1 || C2): Ceq = C1 + C2

2. lépés: Bemenetek

4 bemenetet kell megadnia:

1. Akár ellenállás, akár kondenzátor értékét számítja ki.
2. A cél ellenállás vagy kapacitás értéke és az egységek.
3. Az alkatrészek maximális száma, amelyet használni szeretne a célérték eléréséhez (azaz nem szeretnék 3 ellenállásnál többet használni a célellenállás érték eléréséhez).
4. A jelenlegi ellenállások/kondenzátorok értékeinek listája. Ezeknek az értékeknek ugyanabban az egységben kell lenniük, mint a célértéknek (azaz ha a célérték 110 nF volt, akkor minden értékét nF -ben kell megadni).

3. lépés: Eredmény

3 kimenetet kap az eredményhez:

1. Legközelebbi érték - a legközelebbi ellenállás/kapacitás érték, amelyet a paramétereivel el tudott érni.
2. Különbség - milyen messze volt a legközelebbi érték a célértéktől.
3. Ellenállás/kondenzátor konfiguráció - a használható ellenállások/kondenzátorok értékeinek és konfigurációjának listája.

4. lépés: Az eredmény megértése

A konfigurációs kimenet szabványos jelölést használ. A "+" azt jelenti, hogy az alkatrészek sorban vannak, és a "||" azt jelenti, hogy az alkatrészek párhuzamosan vannak. Az operátorok egyenlő prioritással rendelkeznek, és balról jobbra asszociatívak, azaz a kifejezéseket balról kezdve, jobbra haladva csoportosítja.

Nézze meg például a következő eredményt:

Ellenállás konfiguráció: R0 = 15 ohm + R1 = 470 ohm || R2 = 3300 ohm + R3 = 15000 ohm

Ha követi a fent tárgyalt irányelveket, láthatja, hogy ez egyenértékű a következő egyenlettel és a fenti képpel.

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

5. lépés: További projektek

További projektekért látogasson el oldalaimra:

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

6. lépés: Forráskód

A forráskód megtekintéséhez keresse fel ezt a Github -lerakatot, vagy tekintse meg az alábbi JavaScriptet.

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

/* r/c számológép szkriptje*//* --------------------------------------- -------------------------*/ var legközelebbi_val; // eddigi legközelebbi érték var legközelebbi_diff = 1000000,00; // a val és a cél var különbsége legközelebb = ; // tömb az összetevők értékeinek részletezése var ser_par_config = ; // tömb, amely részletezi a soros/párhuzamos var outputStr = ""; function calculatorClick () {// törli a globális értékeket minden új kattintásnál legközelebbi_val = 0; legközelebbi_diff = 1000000,00; legközelebbi = ; 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; // hiba a célérték elemzésekor, ha (isNaN (cél)) {outputStr = "Hibaellenőrzés" Célérték "bemenet!"} // hiba az összetevők számának elemzésében else if (isNaN (numComp)) {outputStr = "Hibaellenőrzés 'Az összetevők száma' bemenet! "} // else, ha nincs hiba a célban vagy a numComp else if (! IsNaN (cél) &&! IsNaN (számComp)) {while (compValsStr.indexOf (", ")! = -1) {var vessző = compValsStr.indexOf (","); var newInt = parseFloat (compValsStr.substring (0, vessző)); // hiba a komponens értéklistájának elemzésekor, állítsa be a zászlót, ha (isNaN (newInt)) {errFlag = 1; szünet; } compValsStr = compValsStr.substring (vessző+1, compValsStr.length); compVals = newInt; i ++; } var newInt = parseFloat (compValsStr); // hiba a komponens értéklistájának elemzésekor, állítsa be a zászlót, ha (isNaN (newInt)) {errFlag = 1; } compVals = newInt; if (errFlag == 0) {if (document.getElementById ("resRadio"). bejelölve) {ellenállás (target, numComp, compVals); } else if (document.getElementById ("capRadio"). bejelölve) {kondenzátor (cél, számComp, compVals); }} // hiba a komponens értéklista más elemzésekor {outputStr = "Hibaellenőrzés 'Komponensértékek listája' input!"}} calcOutput.innerHTML = outputStr; resultDisplay.style.display = "blokk"; exampleDisplay.style.display = "flex"; // görgessen le az eredményablakhoz.scrollTo (0, exampleDisplay.scrollHeight); } / * A legjobb ellenálláskonfiguráció lekérése és kinyomtatása * cél - célellenállás érték * numComp - az ellenállások teljes száma, amelyet a célérték eléréséhez lehet használni * compVals - ellenállásértékek tömbje * / funkcióellenállás (cél, számComp, compVals) { // ellenállási értékek hossza var num_res = compVals.length; // futtassa végig az összes lehetséges összetevőt (var i = 1; i <= numComp; i ++) {var data = ; resCombination (compVals, num_res, i, 0, data, target); } var egységek = document.getElementById ("selected_unit"). érték; // nyomtatási eredmények outputStr = "Legközelebbi érték:" + legközelebbi_val.toFixed (3) + "" + egység + ""; outputStr + = "Különbség:" + legközelebbi_diff.toFixed (3) + "" + egység + ""; outputStr += "Ellenállás konfiguráció:"; for (var i = 0; i <numComp; i ++) {if (i <legközelebbi.hossz) {outputStr + = "R" + i + "=" + legközelebbi + "" + egység + ""; if (i+1 <legközelebbi.hossz) {if (ser_par_config [i+1]) outputStr+= "||"; else outputStr + = " +"; }} else break; }} /* Kiszámítja az ellenállások legjobb kombinációját a célérték eléréséhez. * res - ellenállásértékek bemeneti tömbje * szám_res - az ellenállásértékek bemeneti tömbjének mérete * num_comb - megengedett ellenállások száma * index - fésű indexe * fésű - az aktuális kombináció tömbje * cél - a célérték * Nincs visszatérési érték - átadja a jelenlegi legjobb kombinációt a globális értékeknek (2, szám_fésű); // 2^(összetevők száma) var ser_par = ; // bool tömb soros vagy párhuzamos megadása minden komponenshez var calc; // számított ekvivalens ellenállásérték // lépjen át az aktuális kombináció minden lehetséges sorozat/párhuzamos konfigurációjában (var j = 0; j k) & 1; } // végezze el a kombináció számításait a sorozat/párhuzamos kombináció alapján a (var k = 0; k <num_comb; k ++) {// első számhoz, csak adja hozzá, ha (k == 0) calc = comb [k]; // a nulla sorozatot jelent, add hozzá az ellenállási értékeket else, ha (! ser_par [k]) calc += comb [k]; // az egyik azt jelenti, hogy párhuzamos, inverz a reciprok összegeivel, ha (ser_par [k]) calc = (calc*comb [k])/(calc+comb [k]); } // ellenőrizze, hogy a különbség kisebb -e, mint az előző legjobb, ha (Math.abs (számítás - cél) <legközelebbi_különbség) {// kisebb, ezért frissítse a globális értékeket legközelebbi_val = számol; legközelebbi_diff = Math.abs (számítás - cél); // nullára törölve (var k = 0; k <num_comb; k ++) {legközelebbi [k] = 0; } // a legközelebbi érték & sorozat/párhuzamos tömbök frissítése (var k = 0; k <szám_comb; k ++) {legközelebbi [k] = fésű [k]; ser_par_config [k] = ser_par [k]; }}} return 0; } // rekurzívan hívja le és cserélje ki az indexet az összes lehetséges értékkel a következőre: (comb i = 0; i = num_comb-index; i ++) {comb [index] = res ; resCombination (res, szám_res, szám_comb, index+1, fésű, cél); }} / * Lekéri és kinyomtatja a legjobb kondenzátor konfigurációt * cél - célkapacitási érték * numComp - a kondenzátorok teljes száma, amelyeket a célérték eléréséhez lehet használni * compVals - kondenzátor értékek tömbje * / funkció kondenzátor (target, numComp, compVals) {// kapacitásértékek hossza var num_cap = compVals.length; // futtassa végig az összes lehetséges összetevőt (var i = 1; i <= numComp; i ++) {var data = ; capCombination (compVals, num_cap, i, 0, data, target); } var egységek = document.getElementById ("selected_unit"). érték; // nyomtatási eredmények outputStr = "Legközelebbi érték:" + legközelebbi_val.toFixed (3) + "" + egység + ""; outputStr + = "Különbség:" + legközelebbi_diff.toFixed (3) + "" + egység + ""; outputStr += "Kondenzátor konfiguráció:"; for (var i = 0; i <numComp; i ++) {if (i <legközelebbi.hossz) {outputStr + = "C" + i + "=" + legközelebbi + "" + egység + ""; if (i+1 <legközelebbi.hossz) {if (ser_par_config [i+1]) outputStr+= "||"; else outputStr + = " +"; }} else break; }} /* Kiszámítja a kondenzátorok legjobb kombinációját a célérték eléréséhez. * cap - kondenzátor értékek bemeneti tömbje * num_cap - a kondenzátor értékek bemeneti tömbjének mérete * num_comb - megengedett kondenzátorok száma * index - fésű indexe * fésű - az aktuális kombináció tömbje * cél - a célérték * Nincs visszatérési érték - átadja a jelenlegi legjobb kombinációt a globális értékeknek (2, szám_fésű); // 2^(összetevők száma) var ser_par = ; // bool tömb soros vagy párhuzamos megadása minden komponenshez var calc; // számított ekvivalens kapacitás -érték // lépjen át az aktuális kombináció minden lehetséges soros/párhuzamos konfigurációjában (var j = 0; j k) & 1; } // végezze el a kombináció számításait sorozat/párhuzamos kombináció alapján (var k = 0; k