Kā panākt jebkādu pretestību/kapacitāti, izmantojot jau esošās sastāvdaļas!: 6 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:51

Tas nav tikai vēl viens sērijas/paralēlas līdzvērtīgas pretestības kalkulators! Šī programma aprēķina, kā apvienot pašreizējos rezistorus/kondensatorus, lai sasniegtu vajadzīgo pretestības/kapacitātes vērtību.

Vai jums kādreiz ir bijis vajadzīgs īpašs rezistors vai kondensators, kura jums nav vai kura nav? Nebaidieties! Jūs, iespējams, varat noteikt šo īpašo pretestības vai kapacitātes vērtību, izmantojot jau esošās sastāvdaļas. Tā vietā, lai atrisinātu milzīgu daudzfaktoru optimizācijas problēmu ar miljoniem dažādu kombināciju, izmantojiet šo programmu!

Vienkārši izvēlieties rezistoru vai kondensatoru, ievadiet mērķa vērtību, ievadiet maksimālo sastāvdaļu skaitu, ko vēlaties izmantot, ievadiet esošo sastāvdaļu vērtību sarakstu un noklikšķiniet uz aprēķināt! Programma izspļaus, kādus komponentus izmantot un kā tos savienot, lai sasniegtu mērķa vērtību.

Lai izmēģinātu kalkulatoru, apmeklējiet šo tīmekļa lietojumprogrammu.

Lai skatītu avota kodu, apmeklējiet šo Github krātuvi.

Lūdzu, dariet man zināmu, vai jums ir kādi ieteikumi, kā vēl vairāk uzlabot šī dizaina rīka lietojamību!

1. darbība. Fons

Šī tīmekļa lietojumprogramma tika izstrādāta pēc nepieciešamības. Es būvēju daudzas dažādas shēmas, kurām nepieciešams ļoti specifisks rezistors vai kondensators. Daudzas reizes man nav rezistora vai kondensatora ar šo īpašo vērtību. Dažreiz viņi pat neveido komponentu ar šo unikālo vērtību! Tā vietā, lai atteiktos vai samierinātos ar kaut ko, kas ir mazāk nekā ideāli, es nolēmu uzrakstīt programmu, lai apskatītu katru iespējamo rezistoru kombināciju (katru iespējamo vērtību un to, vai tie ir virknē vai paralēli) un atgrieztu labāko kombināciju.

Izstrādājot ķēdi savām ērģelēm kā daļu no manas apmācības projektu grupas, man bija jācenšas ar roku aprēķināt labāko kondensatoru kombināciju, lai sasniegtu noteiktu frekvenci. Šis process bija neticami garlaicīgs, un es galu galā vienkārši padevos un izmantoju kondensatoru kombinācijas, kas radīja jebkādu dzirdamu frekvenci. Tagad, izmantojot šo tīmekļa lietojumprogrammu, es varu noformēt savas ērģeles noteiktai frekvencei un noskaņot tās uz tastatūras piezīmēm! Zemāk redzamais vienādojums tiek izmantots, lai aprēķinātu konkrēto frekvenci, un tas tiek apspriests citā Instructables projektā.

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

Izmantojot šo vienādojumu, kur R1 = 100 kOhm un R2 = 10 kOhm, es aprēķināju, ka 27,33 nF kondensators radīs A4 piezīmi (frekvence 440 Hz). Izmantojot savu programmu, es varēju aprēķināt līdzvērtīgu kapacitātes vērtību.001 nF robežās (daudz mazāk nekā standarta kondensatora pielaide), ko varu izveidot, izmantojot jau esošos kondensatorus. Rezultāts un konfigurācija ir aprakstīti zemāk. Tagad es varu daudz efektīvāk un efektīvāk noskaņot savas ērģeles uz precīzām standarta notu frekvencēm. Es vēlētos, lai es to būtu darījis, lai sāktu. Mana demo dziesma uz ērģelēm droši vien būtu skanējusi daudz labāk.

Tuvākā vērtība: 27,329 nF Atšķirība: 0,001 nFC kondensatora konfigurācija: C0 = 0,068 nF || C1 = 30 nF + C2 = 300 nF

Rezistoru kondensatoru ekvivalences vienādojumi

Tālāk ir sniegti līdzvērtības vienādojumi rezistoru un kondensatoru apvienošanai ķēdē.

• Rezistori virknē (R1 + R2): Req = R1 + R2
• Rezistori paralēli (R1 || R2): Req = 1/(1/R1 + 1/R2)
• Kondensatori virknē (C1 + C2): Ceq = 1/(1/C1 + 1/C2)
• Kondensatori paralēli (C1 || C2): Ceq = C1 + C2

2. darbība: ievades

Jums būs jāsniedz 4 ieejas:

1. Neatkarīgi no tā, vai jūs aprēķināt rezistora vai kondensatora vērtību.
2. Mērķa pretestības vai kapacitātes vērtība un vienības.
3. Maksimālais komponentu skaits, ko vēlaties izmantot, lai sasniegtu mērķa vērtību (t.i., lai sasniegtu mērķa pretestības vērtību, es nevēlos izmantot vairāk par 3 rezistoriem).
4. Pašlaik esošo rezistoru/kondensatoru vērtību saraksts. Šīm vērtībām jābūt tādās pašās vienībās kā jūsu mērķvērtībai (t.i., ja jūsu mērķa vērtība bija 110 nF, visas vērtības jānorāda nF).

3. darbība. Rezultāts

Rezultātā jūs iegūsit 3 rezultātus:

1. Tuvākā vērtība - tuvākā pretestības/kapacitātes vērtība, ko varējāt sasniegt ar saviem parametriem.
2. Atšķirība - cik tālu no jūsu tuvākās vērtības bija mērķa vērtība.
3. Rezistoru/kondensatoru konfigurācija - izmantojamo rezistoru/kondensatoru vērtību saraksts un to konfigurācija.

4. darbība. Izpratne par rezultātu

Konfigurācijas izvadei tiek izmantots standarta apzīmējums. "+" nozīmē, ka sastāvdaļas ir virknē un "||" nozīmē, ka sastāvdaļas atrodas paralēli. Operatoriem ir vienāda prioritāte un tie ir asociatīvi no kreisās uz labo, kas nozīmē, ka jūs terminus grupējat kopā, sākot no kreisās puses un virzoties uz labo pusi.

Piemēram, apskatiet šādu rezultātu:

Rezistora konfigurācija: R0 = 15 omi + R1 = 470 omi || R2 = 3300 omi + R3 = 15000 omi

Ja sekojat iepriekš apspriestajām vadlīnijām, jūs varat redzēt, ka tas ir līdzvērtīgs šādam vienādojumam un attēlam iepriekš.

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

5. solis: vairāk projektu

Lai iegūtu vairāk projektu, apmeklējiet manas lapas:

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

6. darbība: avota kods

Lai skatītu avota kodu, apmeklējiet šo Github krātuvi vai skatiet zemāk esošo JavaScript.

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

/* r/c kalkulatora skripts*//* --------------------------------------- -------------------------*/ var vistuvākais_vals; // līdz šim tuvākā vērtība var vistuvākā_diff = 1000000,00; // val atšķirība un mērķa var tuvākais = ; // masīvs detalizējot komponentu vērtības var ser_par_config = ; // masīvs detalizējot seriālo/paralēlo var outputStr = ""; function calculatorClick () {// notīriet globālās vērtības katram jaunam klikšķim tuvākais_val = 0; tuvākais_difs = 1000000,00; tuvākais = ; 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; // kļūda, analizējot mērķa vērtību, ja (isNaN (mērķis)) {outputStr = "Kļūdas pārbaude" ievadiet mērķa vērtību "!" // kļūda, analizējot citu komponentu skaitu, ja (isNaN (numComp)) {outputStr = "Kļūdu pārbaude 'Sastāvdaļu skaits'! '} // cits, ja mērķī nav kļūdas vai numComp cits, ja (! IsNaN (mērķis) &&! IsNaN (numComp)) {while (compValsStr.indexOf (",")! = -1) {var komatu = compValsStr.indexOf (","); var newInt = parseFloat (compValsStr.substring (0, komats)); // kļūda, analizējot komponentu vērtību sarakstu, iestatiet karodziņu, ja (isNaN (newInt)) {errFlag = 1; pārtraukums; } compValsStr = compValsStr.substring (komats+1, compValsStr.length); compVals = newInt; i ++; } var newInt = parseFloat (compValsStr); // kļūda, analizējot komponentu vērtību sarakstu, iestatiet karodziņu, ja (isNaN (newInt)) {errFlag = 1; } compVals = newInt; ja (errFlag == 0) {ja (document.getElementById ("resRadio"). pārbaudīts) {rezistors (mērķis, numComp, compVals); } cits if (document.getElementById ("capRadio"). atzīmēts) {kondensators (mērķis, numComp, compVals); }} // kļūda, parsējot komponentu vērtību sarakstu else {outputStr = "Kļūdu pārbaude 'Component Values List' input!"}} calcOutput.innerHTML = outputStr; resultDisplay.style.display = "bloķēt"; exampleDisplay.style.display = "elastīgs"; // ritiniet uz leju līdz rezultātu window.scrollTo (0, exampleDisplay.scrollHeight); } / * Izgūst un izdrukā labāko rezistoru konfigurāciju * mērķis - mērķa pretestības vērtība * numComp - kopējais rezistoru skaits, ko atļauts izmantot, lai sasniegtu mērķvērtību * compVals - rezistoru vērtību masīvs * / funkcijas rezistors (mērķis, numComp, compVals) { // pretestības vērtību garums var num_res = compVals.length; // palaist cauri visam iespējamajam komponentu skaitam (var i = 1; i <= numComp; i ++) {var data = ; resCombination (compVals, num_res, i, 0, data, target); } var vienības = document.getElementById ("selected_unit"). vērtība; // drukas rezultātu outputStr = "Tuvākā vērtība:" + vistuvākais_val.toFiksēts (3) + "" + vienības + ""; outputStr + = "Atšķirība:" + tuvākais_dif.toFiksēts (3) + "" + vienības + ""; outputStr += "Rezistora konfigurācija:"; par (var i = 0; i <numComp; i ++) {ja (i <tuvākais.garums) {outputStr + = "R" + i + "=" + tuvākais + "" + vienības + ""; ja (i+1 <tuvākais.garums) {ja (ser_par_config [i+1]) outputStr+= "||"; cits outputStr + = " +"; }} cits pārtraukums; }} /* Aprēķina labāko rezistoru kombināciju, lai sasniegtu mērķa vērtību. * res - rezistoru vērtību ievades masīvs * num_res - rezistoru vērtību ievades masīva lielums * num_comb - atļauto rezistoru skaits * indekss - ķemmes indekss * ķemme - pašreizējās kombinācijas masīvs * mērķis - mērķa vērtība * Nav atgriešanās vērtības - pašreizējo labāko kombināciju nodod globālajām vērtībām */ funkcija resCombination (res, num_res, num_comb, index, comb, target) {// pašreizējā kombinācija ir pabeigta, ja (index == num_comb) {var ser_par_size = Math.pow (2, skaitļu_kombinācija); // 2^(komponentu skaits) var ser_par = ; // bool masīvs, kas katram komponentam norāda sēriju vai paralēli var calc; // aprēķinātā ekvivalenta pretestības vērtība // iziet cauri visām iespējamām pašreizējās kombinācijas sērijas/paralēlajām konfigurācijām (var j = 0; j k) & 1; } // veiciet kombinācijas aprēķinus, pamatojoties uz sērijas/paralēlas kombināciju (var k = 0; k <num_comb; k ++) {// pirmais skaitlis, vienkārši pievienojiet, ja (k == 0) calc = ķemme [k]; // nulle nozīmē sēriju, pievienojiet pretestības vērtības citādi, ja (! ser_par [k]) calc += comb [k]; // viens nozīmē paralēlu, apgrieztu otrreizējo vērtību summu, ja (ser_par [k]) calc = (calc*comb [k])/(calc+comb [k]); } // pārbaudiet, vai atšķirība ir mazāka nekā iepriekšējā labākā, ja (Math.abs (calc - target) <vistuvākais_diff) {// tā ir mazāka, tāpēc atjauniniet globālās vērtības vistuvākā_val = calc; vistuvākais_difs = Math.abs (calc - mērķis); // notīrīt līdz nullei (var k = 0; k <num_comb; k ++) {vistuvākais [k] = 0; } // atjaunināt tuvāko vērtību & sērija/paralēli masīvi (var k = 0; k <num_comb; k ++) {vistuvākais [k] = ķemme [k]; ser_par_config [k] = ser_par [k]; }}} atgriezties 0; } // rekursīvi izsaukt un aizstāt indeksu ar visām iespējamām vērtībām (var i = 0; i = num_comb-index; i ++) {comb [index] = res ; resCombination (res, num_res, num_comb, index+1, ķemme, mērķis); }} / * Izgūst un izdrukā labāko kondensatora konfigurāciju * mērķis - mērķa kapacitātes vērtība * numComp - kopējais kondensatoru skaits, ko atļauts izmantot, lai sasniegtu mērķvērtību * compVals - kondensatora vērtību masīvs * / funkcijas kondensators (mērķis, numComp, compVals) {// kapacitātes vērtību garums var num_cap = compVals.length; // palaist cauri visam iespējamajam komponentu skaitam (var i = 1; i <= numComp; i ++) {var data = ; capCombination (compVals, num_cap, i, 0, data, target); } var vienības = document.getElementById ("selected_unit"). vērtība; // drukas rezultātu outputStr = "Tuvākā vērtība:" + vistuvākais_val.toFiksēts (3) + "" + vienības + ""; outputStr + = "Atšķirība:" + tuvākais_dif.toFiksēts (3) + "" + vienības + ""; outputStr += "Kondensatora konfigurācija:"; par (var i = 0; i <numComp; i ++) {ja (i <tuvākais.garums) {outputStr + = "C" + i + "=" + tuvākais + "" + vienības + ""; ja (i+1 <tuvākais.garums) {ja (ser_par_config [i+1]) outputStr+= "||"; cits outputStr + = " +"; }} cits pārtraukums; }} /* Aprēķina labāko kondensatoru kombināciju, lai sasniegtu mērķa vērtību. * cap - kondensatora vērtību ievades masīvs * num_cap - kondensatora vērtību ievades masīva lielums * num_comb - atļauto kondensatoru skaits * indekss - ķemmes indekss * ķemme - pašreizējās kombinācijas masīvs * mērķis - mērķa vērtība * Atgriešanās vērtības nav - pašreizējā labākā kombinācija tiek nodota globālajām vērtībām */ funkciju ierobežojums Kombinācija (maksimālais lielums, skaitļa_cepte, numura_summa, indekss, ķemme, mērķis) {// pašreizējā kombinācija ir pabeigta, ja (indekss == numura_summa) {var ser_par_size = Math.pow (2, skaitļu_kombinācija); // 2^(komponentu skaits) var ser_par = ; // bool masīvs, kas katrai sastāvdaļai norāda sēriju vai paralēli var calc; // aprēķinātā ekvivalenta kapacitātes vērtība // solis cauri visām iespējamām pašreizējās kombinācijas sērijas/paralēlajām konfigurācijām (var j = 0; j k) & 1; } // veiciet kombinācijas aprēķinus, pamatojoties uz sērijas/paralēlas kombināciju (var k = 0; k