Hur man uppnår motstånd/kapacitans med hjälp av komponenter du redan har !: 6 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:35

Detta är inte bara ännu en serie/parallellekvivalentmotståndskalkylator! Detta program beräknar hur man kombinerar motstånd/kondensatorer som du för närvarande har för att uppnå ett målmotstånd/kapacitansvärde som du behöver.

Har du någonsin behövt ett specifikt motstånd eller en kondensator som du inte har eller som inte finns? Var inte rädd! Du kan förmodligen göra det specifika motståndet eller kapacitansvärdet med komponenter som du redan har. Istället för att lösa ett stort multivariabelt optimeringsproblem med miljontals olika kombinationer, använd det här programmet!

Välj bara motstånd eller kondensator, ange målvärdet, mata in det maximala antalet komponenter du vill använda, ange en lista med värdena på komponenterna du har och klicka på beräkna! Programmet spottar ut vilka komponenter som ska användas och hur man ansluter dem för att uppnå ditt målvärde.

För att testa miniräknaren, besök denna webbapplikation.

Om du vill se källkoden besöker du detta Github -arkiv.

Meddela mig om du har några förslag för att ytterligare förbättra användbarheten hos detta designverktyg!

Steg 1: Bakgrund

Denna webbapplikation utvecklades av nödvändighet. Det finns många olika kretsar jag konstruerar som kräver ett mycket specifikt motstånd eller en kondensator. Många gånger har jag inte ett motstånd eller en kondensator med det specifika värdet. Ibland gör de inte ens en komponent med det unika värdet! Istället för att ge upp eller nöja mig med något som är mindre än idealiskt, bestämde jag mig för att skriva ett program för att titta på alla möjliga kombinationer av motstånd (alla möjliga värden och om de är i serie eller parallella) och returnera den bästa kombinationen.

När jag utformade kretsen för mitt organ som en del av mitt Battle of the Bands Instructable -projekt, var jag tvungen att försöka beräkna den bästa kombinationen av kondensatorer för att uppnå en specifik frekvens. Denna process var otroligt tråkig och jag gav så småningom upp och gick med kondensatorkombinationer som producerade hur mycket ljud som helst. Nu med denna webbapplikation kan jag designa mitt orgel för en specifik frekvens och ställa in det på noterna på ett tangentbord! Ekvationen nedan används för att beräkna den specifika frekvensen och diskuteras i det andra Instructables -projektet.

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

Med hjälp av denna ekvation där R1 = 100 kOhm och R2 = 10 kOhm beräknade jag att en 27,33 nF kondensator ger en A4 -ton (frekvens 440 Hz). Med mitt program kunde jag beräkna ett ekvivalent kapacitansvärde inom.001 nF (mycket mindre än toleransen på en standardkondensator) som jag kan skapa med kondensatorer som jag redan hade liggande. Den resulterande utdata och konfiguration beskrivs nedan. Jag kan nu mycket mer effektivt och effektivt ställa in mitt organ på de exakta frekvenserna av standardnoter. Jag önskar att jag hade gjort det här till en början. Min demosång på orgeln hade nog låtit mycket bättre.

Närmaste värde: 27.329 nF Skillnad: 0.001 nFCapacitor konfiguration: C0 = 0.068 nF || C1 = 30 nF + C2 = 300 nF

Motståndskondensatorekvivalensekvationer

För referens, nedan är ekvivalensekvationerna för att kombinera motstånd och kondensatorer i en krets.

• Resistorer i serie (R1 + R2): Req = R1 + R2
• Parallella motstånd (R1 || R2): Req = 1/(1/R1 + 1/R2)
• Kondensatorer i serie (C1 + C2): Ceq = 1/(1/C1 + 1/C2)
• Kondensatorer parallellt (C1 || C2): Ceq = C1 + C2

Steg 2: Ingångar

Det finns fyra ingångar som du måste tillhandahålla:

1. Oavsett om du beräknar ett värde för ett motstånd eller en kondensator.
2. Målmotståndet eller kapacitansvärdet och enheterna.
3. Det maximala antalet komponenter du skulle vilja använda för att uppnå målvärdet (dvs jag skulle inte vilja använda mer än 3 motstånd för att uppnå mitt målmotståndsvärde).
4. Listan över värden för de motstånd/kondensatorer du för närvarande har. Dessa värden ska vara i samma enheter som ditt målvärde (dvs. om ditt målvärde var 110 nF, bör alla dina värden anges i nF).

Steg 3: Resultat

Du får 3 utgångar för ditt resultat:

1. Närmaste värde - det närmaste motstånd/kapacitansvärde du kunde uppnå med dina parametrar.
2. Skillnad - hur långt ifrån ditt närmaste värde var från ditt målvärde.
3. Resistor/kondensatorkonfiguration - en lista med värden för de motstånd/kondensatorer som ska användas och deras konfiguration.

Steg 4: Förstå ditt resultat

Konfigurationsutmatningen använder en standardnotation. "+" betyder att komponenterna är i serie och "||" betyder att komponenterna är parallella. Operatörerna har samma företräde och är associerade från vänster till höger, vilket innebär att du grupperar termer från början till vänster och flyttar till höger.

Ta till exempel en titt på följande resultat:

Motståndskonfiguration: R0 = 15 ohm + R1 = 470 ohm || R2 = 3300 ohm + R3 = 15000 ohm

Om du följer riktlinjerna som diskuterats ovan kan du se att detta motsvarar följande ekvation och bilden ovan.

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

Steg 5: Fler projekt

För fler projekt, besök mina sidor:

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

Steg 6: Källkod

För att se källkoden, besök det här Github -förvaret eller se JavaScript nedan.

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

/* r/c kalkylator scripting*//* --------------------------------------- -------------------------*/ var närmaste_val; // närmaste värde hittills var närmaste_diff = 1000000.00; // diff av val och mål var närmast = ; // arraydetaljerande värden för komponenter var ser_par_config = ; // array som beskriver seriell/parallell var outputStr = ""; function calculatorClick () {// rensa globala värden för varje nytt klick närmaste_val = 0; närmaste_diff = 1000000.00; närmast = ; 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; // fel vid analys av målvärde om (isNaN (target)) {outputStr = "Felkontroll" Målvärde "-inmatning!"} // fel vid analys av antal komponenter annars om (isNaN (numComp)) {outputStr = "Felkontroll 'Antal komponenters inmatning! "} // annars om inget fel i målet eller numComp annars om (! IsNaN (mål) &&! IsNaN (numComp)) {while (compValsStr.indexOf (", ")! = -1) {var komma = compValsStr.indexOf (","); var newInt = parseFloat (compValsStr.substring (0, komma)); // fel vid analys av komponentvärdeslista, ange flagga om (isNaN (newInt)) {errFlag = 1; ha sönder; } compValsStr = compValsStr.substring (komma+1, compValsStr.length); compVals = newInt; i ++; } var newInt = parseFloat (compValsStr); // fel vid analys av komponentvärdeslista, ange flagga om (isNaN (newInt)) {errFlag = 1; } compVals = newInt; if (errFlag == 0) {if (document.getElementById ("resRadio"). kontrollerad) {resistor (target, numComp, compVals); } annars if (document.getElementById ("capRadio"). checkat) {kondensator (target, numComp, compVals); }} // fel vid analys av komponentvärdeslista annars {outputStr = "Felkontroll" Komponentvärdeslista "-inmatning!"}} calcOutput.innerHTML = outputStr; resultDisplay.style.display = "block"; exempelDisplay.style.display = "flex"; // rulla ner till resultat fönster.scrollTo (0, exempelDisplay.scrollHeight); } / * Hämtar och skriver ut den bästa motståndskonfigurationen * mål - målmotståndsvärde * numComp - totalt antal motstånd som får användas för att uppnå målvärde * compVals - array av motståndsvärden * / funktionsmotstånd (target, numComp, compVals) { // längd på motståndsvärden var num_res = compVals.length; // köra igenom alla möjliga antal komponenter för (var i = 1; i <= numComp; i ++) {var data = ; resCombination (compVals, num_res, i, 0, data, target); } var units = document.getElementById ("selected_unit"). värde; // utskriftsresultat outputStr = "Närmaste värde:" + närmaste_val.toFixed (3) + "" + enheter + ""; outputStr + = "Difference:" + close_diff.toFixed (3) + "" + units + ""; outputStr += "Motståndskonfiguration:"; för (var i = 0; i <numComp; i ++) {if (i <närmaste.längd) {outputStr + = "R" + i + "=" + närmaste + "" + enheter + ""; if (i+1 <närmaste.längd) {if (ser_par_config [i+1]) outputStr+= "||"; annars outputStr + = " +"; }} annars går sönder; }} /* Beräknar den bästa kombinationen av motstånd för att uppnå ett målvärde. * res - ingångsgrupp med motståndsvärden * num_res - storlek på ingångsgrupp för motståndsvärden * num_comb - antal tillåtna motstånd * index - index för kam * kam - grupp av aktuell kombination * mål - målvärdet * Inget returvärde - överför nuvarande bästa kombination till globala värden */ function resCombination (res, num_res, num_comb, index, comb, target) {// nuvarande kombination är klar om (index == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2^(antal komponenter) var ser_par = ; // bool array som specificerar seriell eller parallell för varje komponent var calc; // beräknat ekvivalent motståndsvärde // gå igenom alla möjliga serier/parallella konfigurationer av strömkombinationen för (var j = 0; j k) & 1; } // gör beräkningarna för kombinationen baserad på serie/parallellkombination för (var k = 0; k <num_comb; k ++) {// första tal, lägg bara till om (k == 0) calc = kam [k]; // noll betyder serie, lägg till motståndsvärden annars om (! ser_par [k]) calc += kam [k]; // en betyder parallell, invers av summan av ömsesidiga andra om (ser_par [k]) calc = (calc*kam [k])/(calc+kam [k]); } // kolla om skillnaden är mindre än tidigare bäst om (Math.abs (calc - target) <närmaste_diff) {// den är mindre, så uppdatera globala värden närmaste_val = calc; närmaste_diff = Math.abs (kalkyl - mål); // klart till noll för (var k = 0; k <num_comb; k ++) {närmaste [k] = 0; } // uppdatera närmaste värde & serie/parallella matriser för (var k = 0; k <num_comb; k ++) {närmaste [k] = kam [k]; ser_par_config [k] = ser_par [k]; }}} returnera 0; } // kalla rekursivt och ersätt indexet med alla möjliga värden för (var i = 0; i = num_comb-index; i ++) {comb [index] = res ; resCombination (res, num_res, num_comb, index+1, comb, target); }} / * Hämtar och skriver ut den bästa kondensatorns konfiguration * mål - målkapacitansvärde * numComp - totalt antal kondensatorer som kan användas för att uppnå målvärde * compVals - array med kondensatorvärden * / funktionskondensator (mål, numComp, compVals) {// längden på kapacitansvärden var num_cap = compVals.length; // köra igenom alla möjliga antal komponenter för (var i = 1; i <= numComp; i ++) {var data = ; capCombination (compVals, num_cap, i, 0, data, target); } var units = document.getElementById ("selected_unit"). värde; // utskriftsresultat outputStr = "Närmaste värde:" + närmaste_val.toFixed (3) + "" + enheter + ""; outputStr + = "Skillnad:" + närmaste_diff.toFixed (3) + "" + enheter + ""; outputStr += "Kondensatorkonfiguration:"; för (var i = 0; i <numComp; i ++) {if (i <närmaste.längd) {outputStr + = "C" + i + "=" + närmaste + "" + enheter + ""; if (i+1 <närmaste.längd) {if (ser_par_config [i+1]) outputStr+= "||"; annars outputStr + = " +"; }} annars går sönder; }} /* Beräknar den bästa kombinationen av kondensatorer för att uppnå ett målvärde. * cap - ingångsmatris med kondensatorvärden * num_cap - storlek på ingångsmatris med kondensatorvärden * num_comb - antal kondensatorer tillåtna * index - index för kam * kam - array av aktuell kombination * mål - målvärdet * Inget returvärde - överför nuvarande bästa kombination till globala värden */ function capCombination (cap, num_cap, num_comb, index, comb, target) {// nuvarande kombination är komplett om (index == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2^(antal komponenter) var ser_par = ; // bool array som specificerar seriell eller parallell för varje komponent var calc; // beräknat ekvivalent kapacitansvärde // gå igenom alla möjliga serier/parallella konfigurationer av strömkombinationen för (var j = 0; j k) & 1; } // gör beräkningarna för kombinationen baserad på serie/parallellkombination för (var k = 0; k