Hoe om enige weerstand/kapasiteit te bereik met behulp van komponente wat u alreeds het: 6 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:23

Dit is nie net nog 'n reeks/parallelle ekwivalente weerstandsrekenaar nie! Hierdie program bereken hoe u weerstande/kapasitors wat u tans het, moet kombineer om 'n teikenwaarde/kapasitanswaarde wat u benodig, te bereik.

Het u ooit 'n spesifieke weerstand of kapasitor nodig wat u nie het nie of wat nie bestaan nie? Moenie bang wees nie! U kan waarskynlik die spesifieke weerstands- of kapasitanswaarde maak met behulp van komponente wat u reeds het. Gebruik hierdie program in plaas daarvan om 'n groot multivariabele optimaliseringsprobleem op te los met miljoene verskillende kombinasies!

Kies net weerstand of kapasitor, voer die teikenwaarde in, voer die maksimum aantal komponente in wat u wil gebruik, voer 'n lys met die waardes van die komponente in en klik op bereken! Die program spoeg uit watter komponente u moet gebruik en hoe u dit kan koppel om u doelwaarde te bereik.

Besoek hierdie webtoepassing om die sakrekenaar te probeer.

Besoek hierdie Github -bewaarplek om die bronkode te sien.

Laat weet my asseblief as u voorstelle het om die bruikbaarheid van hierdie ontwerphulpmiddel verder te verbeter!

Stap 1: Agtergrond

Hierdie webtoepassing is uit noodsaak ontwikkel. Daar is baie verskillende stroombane wat ek bou wat 'n baie spesifieke weerstand of kapasitor vereis. Ek het baie keer nie 'n weerstand of kapasitor met die spesifieke waarde nie. Soms maak hulle nie eens 'n komponent met die unieke waarde nie! In plaas daarvan om op te gee of te besluit oor iets wat minder as ideaal is, het ek besluit om 'n program te skryf om na elke moontlike kombinasie van weerstande te kyk (elke moontlike waarde en of dit in serie of parallel is) en die beste kombinasie terug te gee.

By die ontwerp van die stroombaan vir my orrel as deel van my Battle of the Bands Instructable Project, moes ek probeer om die beste kombinasie van kapasitors met die hand te bereken om 'n spesifieke frekwensie te bereik. Hierdie proses was ongelooflik vervelig en ek het uiteindelik net opgegee en met kondensatorkombinasies gegaan wat 'n mate van hoorbare frekwensie veroorsaak het. Met hierdie webtoepassing kan ek my orrel vir 'n spesifieke frekwensie ontwerp en dit op die notas op 'n klawerbord afstem! Die vergelyking hieronder word gebruik om die spesifieke frekwensie te bereken en word bespreek in die ander Instructables -projek.

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

Met behulp van hierdie vergelyking waar R1 = 100 kOhm en R2 = 10 kOhm, het ek bereken dat 'n 27.33 nF kapasitor 'n A4 noot (frekwensie 440 Hz) sal lewer. Met behulp van my program kon ek 'n ekwivalente kapasitanswaarde bereken binne 0,001 nF (baie minder as die toleransie op 'n standaard kapasitor) wat ek kan skep met behulp van kapasitors wat ek al gehad het. Die gevolglike uitvoer en konfigurasie word hieronder beskryf. Ek is nou in staat om my orrel doeltreffender en doeltreffender op die presiese frekwensies van standaardnote af te stem. Ek wens ek het dit eers gedoen. My demo -liedjie op die orrel sou waarskynlik baie beter geklink het.

Naaste waarde: 27.329 nF Verskil: 0.001 nFCapacitor Konfigurasie: C0 = 0.068 nF || C1 = 30 nF + C2 = 300 nF

Weerstandskondensator -ekwivalensievergelykings

Ter verwysing is die ekwivalensievergelykings hieronder vir die kombinasie van weerstande en kapasitors in 'n stroombaan.

• Resistors in serie (R1 + R2): Req = R1 + R2
• Parallel weerstande (R1 || R2): Req = 1/(1/R1 + 1/R2)
• Kondensators in serie (C1 + C2): Ceq = 1/(1/C1 + 1/C2)
• Kondensators parallel (C1 || C2): Ceq = C1 + C2

Stap 2: Insette

U moet 4 insette lewer:

1. Of u nou 'n waarde vir 'n weerstand of 'n kapasitor bereken.
2. Die teikenweerstand of kapasitansiewaarde en die eenhede.
3. Die maksimum aantal komponente wat u wil gebruik om die doelwaarde te bereik (dit wil sê, ek wil nie meer as 3 weerstande gebruik om my doelweerstandwaarde te bereik nie).
4. Die lys waardes vir die weerstande/kapasitors wat u tans het. Hierdie waardes moet in dieselfde eenhede as u teikenwaarde wees (dit wil sê as u teikenwaarde 110 nF was, moet al u waardes in nF verskaf word).

Stap 3: Resultaat

U kry 3 uitsette vir u resultaat:

1. Naaste waarde - die naaste weerstand/kapasitanswaarde wat u met u parameters kon bereik.
2. Verskil - hoe ver die naaste waarde van u teikenwaarde was.
3. Weerstand/kondensatorkonfigurasie - 'n lys met waardes van die weerstande/kapasitors wat gebruik moet word en die konfigurasie daarvan.

Stap 4: Verstaan u resultaat

Die konfigurasie -uitvoer gebruik 'n standaardnotasie. "+" beteken dat die komponente in serie is en "||" beteken dat die komponente parallel is. Die operateurs het dieselfde voorrang en is links-na-regs assosiatief, wat beteken dat u terme saamgroepeer, van links na regs.

Kyk byvoorbeeld na die volgende resultaat:

Weerstandskonfigurasie: R0 = 15 ohm + R1 = 470 ohm || R2 = 3300 ohm + R3 = 15000 ohm

As u die bogenoemde riglyne volg, kan u sien dat dit gelykstaande is aan die volgende vergelyking en die prent hierbo.

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

Stap 5: Meer projekte

Besoek my bladsye vir meer projekte:

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

Stap 6: Bronkode

Besoek hierdie Github -bewaarplek of sien die JavaScript hieronder om die bronkode te sien.

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

/* r/c sakrekenaarskrif*//* --------------------------------------- -------------------------*/ var naaste_waarde; // naaste waarde tot dusver var naaste_verskil = 1000000.00; // diff van val en target var naaste = ; // skikking met waardes van komponente var ser_par_config = ; // skikking wat die seriële/parallelle var outputStr = "" uiteensit; funksie sakrekenaar Klik () {// verwyder globale waardes vir elke nuwe klik naaste_waarde = 0; naaste_verskil = 1000000.00; naaste = ; 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; // fout by die ontleding van teikenwaarde as (isNaN (doel)) {outputStr = "Foutkontrole 'Doelwaarde' invoer!"} // fout in ontleding van aantal komponente anders as (isNaN (numComp)) {outputStr = "Foutkontrole 'Aantal komponente se invoer!'} // anders as daar geen fout in die teiken of numComp anders is as (! IsNaN (teiken) &&! IsNaN (numComp)) {terwyl (compValsStr.indexOf (",")! = -1) {var komma = compValsStr.indexOf (","); var newInt = parseFloat (compValsStr.substring (0, komma)); // fout by die ontleding van komponentwaarde lys, stel vlag as (isNaN (newInt)) {errFlag = 1; breek; } compValsStr = compValsStr.substring (komma+1, compValsStr.length); compVals = newInt; ek ++; } var newInt = parseFloat (compValsStr); // fout by die ontleding van komponentwaarde lys, stel vlag as (isNaN (newInt)) {errFlag = 1; } compVals = newInt; if (errFlag == 0) {if (document.getElementById ("resRadio"). nagegaan) {resistor (target, numComp, compVals); } anders as (document.getElementById ("capRadio"). nagegaan) {capacitor (target, numComp, compVals); }}} // fout by die ontleding van komponentwaardelys anders {outputStr = "Foutkontrole 'Komponentwaardelys' invoer!"}} calcOutput.innerHTML = outputStr; resultDisplay.style.display = "blok"; exampleDisplay.style.display = "flex"; // blaai af na resultaat venster.scrollTo (0, exampleDisplay.scrollHeight); } / * Haal en druk die beste weerstandskonfigurasie uit * teiken - teikenweerstandswaarde * numComp - totale aantal weerstande wat gebruik kan word om doelwit * compVals - skikking van weerstandswaardes * / funksieweerstand (doel, numComp, compVals) { // lengte van weerstandswaardes var num_res = compVals.length; // loop deur alle moontlike aantal komponente vir (var i = 1; i <= numComp; i ++) {var data = ; resCombination (compVals, num_res, i, 0, data, target); } var units = document.getElementById ("selected_unit"). waarde; // drukresultate outputStr = "Naaste waarde:" + naaste_waarde.toFiks (3) + "" + eenhede + ""; outputStr + = "Difference:" + close_diff.toFixed (3) + "" + units + ""; outputStr += "Weerstandkonfigurasie:"; for (var i = 0; i <numComp; i ++) {if (i <close.length) {outputStr + = "R" + i + "=" + naaste + "" + eenhede + ""; if (i+1 <naaste.lengte) {if (ser_par_config [i+1]) outputStr+= "||"; anders outputStr + = " +"; }} anders breek; }} /* Bereken die beste kombinasie van weerstande om 'n teikenwaarde te bereik. * res - invoerreeks van weerstandswaardes * num_res - grootte van invoerreeks van weerstandswaardes * num_comb - aantal weerstande toegelaat * indeks - indeks van kam * kam - skikking van huidige kombinasie * teiken - die doelwaarde * Geen opbrengswaarde nie - gee die beste kombinasie van die huidige aan globale waardes */ funksie resCombination (res, num_res, num_comb, index, comb, target) {// huidige kombinasie is voltooi as (index == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2^(aantal komponente) var ser_par = ; // bool -skikking wat reeks of parallel spesifiseer vir elke komponent var calc; // berekende ekwivalente weerstandswaarde // stap deur elke moontlike reeks/parallelle konfigurasie van die huidige kombinasie vir (var j = 0; j k) & 1; } // doen die berekeninge vir die kombinasie gebaseer op reeks/parallelle kombinasie vir (var k = 0; k <num_comb; k ++) {// eerste getal, voeg net by as (k == 0) calc = kam [k]; // nul beteken reeks, voeg weerstandswaardes by, anders as (! ser_par [k]) calc += kam [k]; // een beteken parallel, omgekeerd van die som van wederkeriges anders as (ser_par [k]) calc = (calc*kam [k])/(calc+kam [k]); } // kyk of die verskil minder is as die vorige beste as (Math.abs (calc - target) <naaste_verskil) {// dit minder is, dus werk globale waardes naaste_val = calc op; naaste_verskil = Wiskunde.abs (berekening - teiken); // duidelik tot nul vir (var k = 0; k <num_comb; k ++) {naaste [k] = 0; } // werk die naaste waarde en reekse/parallelle skikkings op vir (var k = 0; k <num_comb; k ++) {naaste [k] = kam [k]; ser_par_config [k] = ser_par [k]; }}} gee 0 terug; } // bel en vervang die indeks rekursief met alle moontlike waardes vir (var i = 0; i = num_comb-index; i ++) {comb [index] = res ; resCombination (res, num_res, num_comb, index+1, comb, target); }} / * Haal en druk die beste kondensatorkonfigurasie * teiken - teikenkapasitansiewaarde * numComp - totale aantal kapasitors wat toegelaat kan word om doelwit * compVals te bereik - verskeidenheid kondensatorwaardes * / funksie kapasitor (target, numComp, compVals) {// lengte van kapasitansie waardes var num_cap = compVals.length; // loop deur alle moontlike aantal komponente vir (var i = 1; i <= numComp; i ++) {var data = ; capCombination (compVals, num_cap, i, 0, data, target); } var units = document.getElementById ("selected_unit"). waarde; // drukresultate outputStr = "Naaste waarde:" + naaste_waarde.toFiks (3) + "" + eenhede + ""; outputStr + = "Difference:" + close_diff.toFixed (3) + "" + units + ""; outputStr += "Kondensatorkonfigurasie:"; for (var i = 0; i <numComp; i ++) {if (i <close.length) {outputStr + = "C" + i + "=" + naaste + "" + eenhede + ""; if (i+1 <naaste.lengte) {if (ser_par_config [i+1]) outputStr+= "||"; anders outputStr + = " +"; }} anders breek; }} /* Bereken die beste kombinasie van kapasitors om 'n teikenwaarde te bereik. * cap - invoerreeks van kondensatorwaardes * num_cap - grootte van invoerreeks van kondensatorwaardes * num_comb - aantal toegelate kondensators * indeks - indeks van kam * kam - skikking van huidige kombinasie * teiken - die doelwaarde * Geen opbrengswaarde nie - gee die beste kombinasie van die huidige aan globale waardes */ function capCombination (cap, num_cap, num_comb, index, comb, target) {// huidige kombinasie is voltooi as (index == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2^(aantal komponente) var ser_par = ; // bool skikking wat die reeks of parallel spesifiseer vir elke komponent var calc; // berekende ekwivalente kapasitansiewaarde // stap deur elke moontlike reeks/parallelle konfigurasie van die huidige kombinasie vir (var j = 0; j k) & 1; } // doen die berekeninge vir die kombinasie gebaseer op reeks/parallelle kombinasie vir (var k = 0; k