So erreichen Sie jeden Widerstand/Kapazität mit Komponenten, die Sie bereits haben! - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:15

Dies ist nicht nur ein weiterer Reihen-/Parallel-Äquivalentwiderstandsrechner! Dieses Programm berechnet, wie Sie Widerstände/Kondensatoren kombinieren, die Sie derzeit benötigen, um einen gewünschten Widerstands-/Kapazitätszielwert zu erreichen.

Haben Sie jemals einen bestimmten Widerstand oder Kondensator benötigt, den Sie nicht haben oder den es nicht gibt? Hab keine Angst! Sie können diesen spezifischen Widerstands- oder Kapazitätswert wahrscheinlich mit bereits vorhandenen Komponenten erstellen. Anstatt ein riesiges multivariables Optimierungsproblem mit Millionen verschiedener Kombinationen zu lösen, verwenden Sie dieses Programm!

Wählen Sie einfach Widerstand oder Kondensator, geben Sie den Zielwert ein, geben Sie die maximale Anzahl der Komponenten ein, die Sie verwenden möchten, geben Sie eine Liste der Werte der Komponenten ein, die Sie haben, und klicken Sie auf Berechnen! Das Programm spuckt aus, welche Komponenten zu verwenden sind und wie Sie sie verbinden, um Ihren Zielwert zu erreichen.

Um den Rechner auszuprobieren, besuchen Sie diese Webanwendung.

Um den Quellcode anzuzeigen, besuchen Sie dieses Github-Repository.

Bitte lassen Sie es mich wissen, wenn Sie Vorschläge zur weiteren Verbesserung der Benutzerfreundlichkeit dieses Designtools haben!

Schritt 1: Hintergrund

Diese Webanwendung wurde aus der Not heraus entwickelt. Es gibt viele verschiedene Schaltungen, die ich konstruiere, die einen ganz bestimmten Widerstand oder Kondensator erfordern. Oft habe ich keinen Widerstand oder Kondensator mit diesem spezifischen Wert. Manchmal stellen sie nicht einmal eine Komponente mit diesem einzigartigen Wert her! Anstatt aufzugeben oder mich mit etwas zufriedenzugeben, das nicht ideal ist, habe ich beschlossen, ein Programm zu schreiben, das jede mögliche Kombination von Widerständen (jeden möglichen Wert und ob sie in Reihe oder parallel sind) untersucht und die beste Kombination zurückgibt.

Beim Entwerfen der Schaltung für meine Orgel als Teil meines Battle of the Bands Instructable Project musste ich versuchen, die beste Kombination von Kondensatoren von Hand zu berechnen, um eine bestimmte Frequenz zu erreichen. Dieser Prozess war unglaublich mühsam und ich gab schließlich einfach auf und ging zu Kondensatorkombinationen, die jede Menge hörbarer Frequenzen erzeugten. Jetzt kann ich mit dieser Webanwendung meine Orgel für eine bestimmte Frequenz konzipieren und auf die Töne einer Tastatur stimmen! Die folgende Gleichung wird verwendet, um die spezifische Frequenz zu berechnen und wird im anderen Instructables-Projekt besprochen.

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

Mit dieser Gleichung mit R1 = 100 kOhm und R2 = 10 kOhm habe ich berechnet, dass ein 27,33 nF Kondensator eine A4-Note (Frequenz 440 Hz) erzeugt. Mit meinem Programm konnte ich einen äquivalenten Kapazitätswert innerhalb von 0,001 nF (viel weniger als die Toleranz eines Standardkondensators) berechnen, den ich mit Kondensatoren erstellen kann, die ich bereits herumgelegt hatte. Die resultierende Ausgabe und Konfiguration wird unten beschrieben. Ich bin jetzt in der Lage, meine Orgel viel effizienter und effektiver auf die exakten Frequenzen von Standardtönen zu stimmen. Ich wünschte, ich hätte das von Anfang an getan. Mein Demosong auf der Orgel hätte wahrscheinlich viel besser geklungen.

Nächster Wert: 27,329 nF Differenz: 0,001 nFC Kondensatorkonfiguration: C0=0,068 nF || C1=30 nF + C2=300 nF

Widerstandskondensator-Äquivalenzgleichungen

Als Referenz sind unten die Äquivalenzgleichungen zum Kombinieren von Widerständen und Kondensatoren in einer Schaltung.

• Widerstände in Reihe (R1 + R2): Req = R1 + R2
• Widerstände parallel (R1 || R2): Req = 1 / (1/R1 + 1/R2)
• Kondensatoren in Reihe (C1 + C2): Ceq = 1 / (1/C1 + 1/C2)
• Kondensatoren parallel (C1 || C2): Ceq = C1 + C2

Schritt 2: Eingaben

Es gibt 4 Eingaben, die Sie bereitstellen müssen:

1. Ob Sie einen Wert für einen Widerstand oder einen Kondensator berechnen.
2. Der Zielwiderstands- oder Kapazitätswert und die Einheiten.
3. Die maximale Anzahl von Komponenten, die Sie verwenden möchten, um den Zielwert zu erreichen (d. h. ich möchte nicht mehr als 3 Widerstände verwenden, um meinen Zielwiderstandswert zu erreichen).
4. Die Liste der Werte für die Widerstände/Kondensatoren, die Sie derzeit haben. Diese Werte sollten in denselben Einheiten wie Ihr Zielwert angegeben werden (d. h. wenn Ihr Zielwert 110 nF betrug, sollten alle Ihre Werte in nF angegeben werden).

Schritt 3: Ergebnis

Sie erhalten 3 Ausgaben für Ihr Ergebnis:

1. Nächster Wert - Der nächste Widerstands-/Kapazitätswert, den Sie mit Ihren Parametern erreichen konnten.
2. Differenz – wie weit Ihr nächster Wert von Ihrem Zielwert entfernt war.
3. Widerstands-/Kondensatorkonfiguration – eine Liste mit Werten der zu verwendenden Widerstände/Kondensatoren und ihrer Konfiguration.

Schritt 4: Ihr Ergebnis verstehen

Die Konfigurationsausgabe verwendet eine Standardschreibweise. "+" bedeutet, dass die Komponenten in Reihe geschaltet sind und "||" bedeutet, dass die Komponenten parallel sind. Die Operatoren haben die gleiche Priorität und sind von links nach rechts assoziativ, d. h. Sie gruppieren Begriffe von links nach rechts.

Schauen Sie sich zum Beispiel das folgende Ergebnis an:

Widerstandskonfiguration: R0=15 Ohm + R1=470 Ohm || R2 = 3300 Ohm + R3 = 15000 Ohm

Wenn Sie die oben besprochenen Richtlinien befolgen, können Sie sehen, dass dies der folgenden Gleichung und dem obigen Bild entspricht.

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

Schritt 5: Weitere Projekte

Weitere Projekte finden Sie auf meinen Seiten:

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

Schritt 6: Quellcode

Um den Quellcode anzuzeigen, besuchen Sie dieses Github-Repository oder sehen Sie sich das JavaScript unten an.

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

/* r/c-Rechner-Skripting */ /* --------------------------------------- --------------------------*/ var am nächsten_val; // bisher nächster Wert var engste_diff = 1000000.00; // Diff von val und Zielvariable am nächsten = ; // Array mit Detailwerten der Komponenten var ser_par_config = ; // Array, das seriell/parallel detailliert var outputStr = ""; functioncalculatorClick () { // Globale Werte für jeden neuen Klick löschen close_val = 0; nächste_diff = 1000000,00; am nächsten = ; 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] = ""; vari = 0; var errFlag = 0; // Fehler beim Parsen des Zielwerts if (isNaN(target)) { outputStr = "Fehlerprüfung 'Zielwert' input! " } // Fehler beim Parsen der Anzahl der Komponenten else if (isNaN(numComp)){ outputStr = "Fehlerprüfung 'Anzahl der Komponenten' Eingabe! " } // else if kein Fehler in target oder numComp else if (!isNaN(target) && !isNaN(numComp)) { while (compValsStr.indexOf(", ") != -1) { var Komma = compValsStr.indexOf(", "); var newInt = parseFloat(compValsStr.substring(0, Komma)); // Fehler beim Parsen der Komponentenwertliste, setze Flag if (isNaN(newInt)) { errFlag = 1; brechen; } compValsStr = compValsStr.substring(comma+1, compValsStr.length); compVals = newInt; i++; } var newInt = parseFloat(compValsStr); // Fehler beim Parsen der Komponentenwertliste, setze Flag if (isNaN(newInt)) { errFlag = 1; } compVals = newInt; if (errFlag == 0) { if (document.getElementById("resRadio").checked) { Widerstand (target, numComp, compVals); aufrechtzuerhalten. Sonst if (document.getElementById("capRadio").checked) { Kondensator (Ziel, numComp, compVals); } } // Fehler beim Parsen der Komponentenwertliste else { outputStr = "Fehler beim Überprüfen der Eingabe der Komponentenwerteliste!" } } calcOutput.innerHTML = outputStr; resultDisplay.style.display = "block"; exampleDisplay.style.display = "flex"; // nach unten scrollen zum Ergebnis window.scrollTo(0, exampleDisplay.scrollHeight); } /* Ruft die beste Widerstandskonfiguration ab und druckt sie * target - Zielwiderstandswert * numComp - Gesamtzahl der Widerstände, die zum Erreichen des Zielwertes verwendet werden dürfen * compVals - Array von Widerstandswerten */ function resistance(target, numComp, compVals) { // Länge der Widerstandswerte var num_res = compVals.length; // alle möglichen Komponenten durchlaufen für (var i=1; i<=numComp; i++) { var data = ; resCombination(compVals, num_res, i, 0, Daten, Ziel); } var units = document.getElementById("selected_unit").value; // Ergebnisse ausgeben outputStr = "Nächster Wert: " + engste_val.toFixed(3) + " " + Einheiten + " "; outputStr += "Differenz: " + engste_diff.toFixed(3) + " " + Einheiten + " "; outputStr += "Widerstandskonfiguration: "; for (var i=0; i<numComp; i++) { if (i<closest.length) { outputStr += "R" + i + "=" + nächste + " " + units + " "; if (i+1<nächste. Länge) { if (ser_par_config[i+1]) outputStr += "|| "; sonst AusgabeStr += "+"; } } else break; } } /* Berechnet die beste Kombination von Widerständen, um einen Zielwert zu erreichen. * res - Eingabe-Array der Widerstandswerte * num_res - Größe des Eingabe-Arrays der Widerstandswerte * num_comb - Anzahl der zulässigen Widerstände * Index - Index von Kamm * Kamm - Array der aktuellen Kombination * Ziel - der Zielwert * Kein Rückgabewert - übergibt die aktuelle beste Kombination an globale Werte */ function resCombination(res, num_res, num_comb, index, comb, target) { // aktuelle Kombination ist vollständig if (index == num_comb) { var ser_par_size = Math.pow (2, num_comb); // 2^(Anzahl der Komponenten) var ser_par = ; // bool Array, das für jede Komponente seriell oder parallel angibt var calc; // berechneter äquivalenter Widerstandswert // Schritt für Schritt durch jede mögliche Reihen-/Parallelkonfiguration der aktuellen Kombination für (var j=0; j k) & 1; } // führe die Berechnungen für die Kombination basierend auf der Serien/Parallel-Kombination durch für (var k=0; k<num_comb; k++) { // erste Zahl, addiere einfach if (k==0) calc = comb[k]; // Null bedeutet Serie, Widerstandswerte hinzufügen else if (!ser_par[k]) calc += comb[k]; // one bedeutet parallel, Kehrwert der Summe der Kehrwerte else if (ser_par[k]) calc = (calc*comb[k])/(calc+comb[k]); } // Überprüfen Sie, ob die Differenz kleiner ist als die vorherige beste if (Math.abs(calc - target) < engste_diff) { // sie ist kleiner, also aktualisieren Sie die globalen Werte close_val = calc; near_diff = Math.abs(calc - target); // auf Null löschen für (var k=0; k<num_comb; k++) { am nächsten[k] = 0; } // aktualisiere den nächsten Wert & Reihen/Parallel-Arrays für (var k=0; k<num_comb; k++) { am nächsten[k] = kam[k]; ser_par_config[k] = ser_par[k]; } } } Rückgabe 0; } // rekursiv aufrufen und den Index durch alle möglichen Werte ersetzen for (var i=0; i= num_comb-index; i++) { comb[index] = res; resCombination(res, num_res, num_comb, index+1, Kamm, Ziel); } } /* Ruft die beste Kondensatorkonfiguration ab und druckt sie * target - Zielkapazitätswert * numComp - Gesamtzahl der Kondensatoren, die verwendet werden dürfen, um den Zielwert zu erreichen * compVals - Array von Kondensatorwerten */ function console(target, numComp, compVals) { // Länge der Kapazitätswerte var num_cap = compVals.length; // alle möglichen Komponenten durchlaufen für (var i=1; i<=numComp; i++) { var data = ; capCombination(compVals, num_cap, i, 0, Daten, Ziel); } var units = document.getElementById("selected_unit").value; // Ergebnisse ausgeben outputStr = "Nächster Wert: " + engste_val.toFixed(3) + " " + Einheiten + " "; outputStr += "Differenz: " + engste_diff.toFixed(3) + " " + Einheiten + " "; outputStr += "Kondensatorkonfiguration: "; for (var i=0; i<numComp; i++) { if (i<closest.length) { outputStr += "C" + i + "=" + nächste + " " + units + " "; if (i+1<closest.length) { if (ser_par_config[i+1]) outputStr += "|| "; sonst AusgabeStr += "+"; } } else break; } } /* Berechnet die beste Kombination von Kondensatoren, um einen Zielwert zu erreichen. * cap - Eingabe-Array von Kondensatorwerten * num_cap - Größe des Eingabe-Arrays von Kondensatorwerten * num_comb - Anzahl der zulässigen Kondensatoren * Index - Index von comb * comb - Array der aktuellen Kombination * target - der Zielwert * Kein Rückgabewert - übergibt die aktuelle beste Kombination an globale Werte */ function capCombination(cap, num_cap, num_comb, index, comb, target) { // aktuelle Kombination ist vollständig if (index == num_comb) { var ser_par_size = Math.pow (2, num_comb); // 2^(Anzahl der Komponenten) var ser_par = ; // bool Array, das für jede Komponente seriell oder parallel angibt var calc; // berechneter äquivalenter Kapazitätswert // Schritt für Schritt durch jede mögliche Reihen-/Parallelkonfiguration der Stromkombination für (var j=0; j k) & 1; } // mach die Berechnungen für die Kombination basierend auf der Serie/Parallel-Kombination für (var k=0; k