Cara Mencapai Sebarang Rintangan / Kapasitansi Menggunakan Komponen yang Sudah Anda Miliki !: 6 Langkah

2024 Pengarang: John Day | [email protected]. Diubah suai terakhir: 2024-01-30 11:06

Ini bukan hanya kalkulator rintangan setara siri / selari yang lain! Program ini mengira cara menggabungkan perintang / kapasitor yang anda perlukan sekarang untuk mencapai nilai rintangan / kapasitansi sasaran yang anda perlukan.

Adakah anda memerlukan perintang atau kapasitor tertentu yang tidak anda miliki atau yang tidak ada? Tidak takut! Anda mungkin boleh membuat nilai rintangan atau kapasitansi tertentu menggunakan komponen yang sudah anda miliki. Daripada menyelesaikan masalah pengoptimuman multivariabel yang besar dengan berjuta-juta kombinasi yang berbeza, gunakan program ini!

Cukup pilih perintang atau kapasitor, masukkan nilai sasaran, masukkan bilangan maksimum komponen yang ingin anda gunakan, masukkan senarai nilai komponen yang anda ada, dan klik hitung! Program ini akan memaparkan komponen apa yang akan digunakan dan cara menghubungkannya untuk mencapai nilai sasaran anda.

Untuk mencuba kalkulator, kunjungi aplikasi web ini.

Untuk melihat kod sumber, kunjungi repositori Github ini.

Beritahu saya jika anda mempunyai cadangan untuk meningkatkan lagi kebolehgunaan alat reka bentuk ini!

Langkah 1: Latar belakang

Aplikasi web ini dibangunkan kerana keperluan. Terdapat banyak rangkaian yang saya bina yang menuntut perintang atau kapasitor yang sangat spesifik. Berkali-kali, saya tidak mempunyai perintang atau kapasitor dengan nilai tertentu. Kadang-kadang mereka bahkan tidak membuat komponen dengan nilai unik itu! Daripada menyerah atau menyelesaikan sesuatu yang kurang ideal, saya memutuskan untuk menulis program untuk melihat setiap kemungkinan kombinasi perintang (setiap nilai yang mungkin dan sama ada dalam siri atau selari) dan mengembalikan kombinasi terbaik.

Semasa merancang litar untuk organ saya sebagai sebahagian daripada Projek Instruksional Battle of the Bands saya, saya terpaksa berusaha mengira kombinasi kapasitor terbaik untuk mencapai frekuensi tertentu. Proses ini sangat membosankan dan akhirnya saya berhenti dan menggunakan kombinasi kapasitor yang menghasilkan sebilangan frekuensi yang dapat didengar. Sekarang dengan aplikasi web ini, saya dapat merancang organ saya untuk frekuensi tertentu dan menyesuaikannya dengan nota pada papan kekunci! Persamaan di bawah digunakan untuk mengira frekuensi tertentu dan dibincangkan dalam projek Instructables yang lain.

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

Dengan menggunakan persamaan ini di mana R1 = 100 kOhm dan R2 = 10 kOhm, saya mengira bahawa kapasitor 27.33 nF akan menghasilkan nota A4 (frekuensi 440 Hz). Dengan menggunakan program saya, saya dapat mengira nilai kapasitans yang setara dalam 0,001 nF (lebih rendah daripada toleransi pada kapasitor standard) yang boleh saya buat menggunakan kapasitor yang sudah saya miliki. Output dan konfigurasi yang dihasilkan dijelaskan di bawah. Saya sekarang dapat menyesuaikan organ saya dengan frekuensi nota standard yang lebih tepat dan berkesan. Saya harap saya telah melakukan ini sebagai permulaan. Lagu demo saya di organ mungkin akan terdengar lebih baik.

Nilai terdekat: 27.329 nF Perbezaan: 0,001 nFC Konfigurasi kapasitor: C0 = 0,068 nF || C1 = 30 nF + C2 = 300 nF

Persamaan Kesamaan Kapasitor Resistor

Sebagai rujukan, berikut adalah persamaan kesetaraan untuk menggabungkan perintang dan kapasitor dalam litar.

• Perintang dalam siri (R1 + R2): Req = R1 + R2
• Perintang selari (R1 || R2): Req = 1 / (1 / R1 + 1 / R2)
• Kapasitor dalam siri (C1 + C2): Ceq = 1 / (1 / C1 + 1 / C2)
• Kapasitor selari (C1 || C2): Ceq = C1 + C2

Langkah 2: Input

Terdapat 4 input yang perlu anda berikan:

1. Sama ada anda mengira nilai untuk perintang atau kapasitor.
2. Nilai rintangan atau kapasitansi sasaran dan unit.
3. Jumlah maksimum komponen yang anda ingin gunakan untuk mencapai nilai sasaran (iaitu, saya tidak mahu menggunakan lebih daripada 3 perintang untuk mencapai nilai rintangan sasaran saya).
4. Senarai nilai untuk perintang / kapasitor yang anda ada sekarang. Nilai-nilai ini harus dalam unit yang sama dengan nilai sasaran anda (iaitu jika nilai sasaran anda adalah 110 nF, semua nilai anda harus diberikan dalam nF).

Langkah 3: Hasilnya

Anda akan mendapat 3 output untuk hasil anda:

1. Nilai terdekat - nilai rintangan / kapasitansi terdekat yang anda dapat capai dengan parameter anda.
2. Perbezaan - sejauh mana nilai terdekat anda dari nilai sasaran anda.
3. Konfigurasi Resistor / Kapasitor - senarai nilai perintang / kapasitor yang akan digunakan dan konfigurasi mereka.

Langkah 4: Memahami Hasil Anda

Output konfigurasi menggunakan notasi standard. "+" bermaksud komponennya dalam siri dan "||" bermaksud komponennya selari. Pengendali mempunyai keutamaan yang sama dan bersekutu kiri-ke-kanan yang bermaksud anda mengumpulkan istilah bermula dari kiri dan bergerak ke kanan.

Sebagai contoh, perhatikan hasil berikut:

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

Sekiranya anda mengikuti garis panduan yang dibincangkan di atas, anda dapat melihat bahawa ini sama dengan persamaan dan gambar berikut di atas.

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

Langkah 5: Lebih Banyak Projek

Untuk lebih banyak projek, lawati halaman saya:

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

Langkah 6: Kod Sumber

Untuk melihat kod sumber, kunjungi repositori Github ini atau lihat JavaScript di bawah.

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

/ * skrip kalkulator r / c * / / * --------------------------------------- ------------------------- * / var terdekat_val; // nilai terdekat setakat ini var terdekat_diff = 1000000.00; // diff of val dan target var terdekat = ; // array memperincikan nilai komponen var ser_par_config = ; // array memperincikan siri output / selari var outputStr = ""; fungsi kalkulatorKlik () {// kosongkan nilai global untuk setiap klik baru terdekat_val = 0; terdekat_diff = 1000000.00; paling hampir = ; 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; // kesalahan dalam menguraikan nilai sasaran jika (isNaN (target)) {outputStr = "Ralat periksa input 'Nilai Sasaran'!"} // ralat menguraikan bilangan komponen lain jika (isNaN (numComp)) {outputStr = "Pemeriksaan ralat 'Jumlah komponen' masukan! "} // lain jika tiada ralat pada sasaran atau numComp lain jika (! IsNaN (target) &&! IsNaN (numComp)) {while (compValsStr.indexOf (", ")! = -1) {var comma = compValsStr.indexOf (","); var newInt = parseFloat (compValsStr.substring (0, koma)); // ralat dalam menguraikan senarai nilai komponen, tetapkan bendera jika (isNaN (newInt)) {errFlag = 1; rehat; } compValsStr = compValsStr.substring (koma + 1, compValsStr.length); compVals = newInt; saya ++; } var newInt = parseFloat (compValsStr); // ralat dalam menguraikan senarai nilai komponen, tetapkan bendera jika (isNaN (newInt)) {errFlag = 1; } compVals = newInt; if (errFlag == 0) {if (document.getElementById ("resRadio"). diperiksa) {resistor (target, numComp, compVals); } lain jika (document.getElementById ("capRadio"). diperiksa) {kapasitor (target, numComp, compVals); }} // ralat dalam menguraikan senarai nilai komponen yang lain {outputStr = "Ralat periksa input 'Daftar Nilai Komponen'!"}} calcOutput.innerHTML = outputStr; resultDisplay.style.display = "blok"; contohDisplay.style.display = "flex"; // tatal ke bawah ke window hasil.scrollTo (0, exampleDisplay.scrollHeight); } / * Mengambil dan mencetak konfigurasi perintang terbaik * sasaran - nilai rintangan sasaran * numComp - jumlah perintang yang dibenarkan digunakan untuk mencapai sasaran val * compVals - susunan nilai perintang * / perintang fungsi (sasaran, numComp, compVals) { // panjang nilai rintangan var num_res = compVals.length; // jalankan semua kemungkinan komponen untuk (var i = 1; i <= numComp; i ++) {var data = ; resCombination (compVals, num_res, i, 0, data, target); } unit var = document.getElementById ("select_unit"). nilai; // hasil cetak outputStr = "Nilai terdekat:" + terdekat_val.toFixed (3) + "" + unit + ""; outputStr + = "Perbezaan:" + terdekat_diff.toFixed (3) + "" + unit + ""; outputStr + = "Konfigurasi Resistor:"; untuk (var i = 0; i <numComp; i ++) {if (i <terdekat.length) {outputStr + = "R" + i + "=" + terdekat + "" + unit + ""; if (i + 1 <terdekat.length) {if (ser_par_config [i + 1]) outputStr + = "||"; outputStr + = "+" yang lain; }} rehat yang lain; }} / * Mengira kombinasi perintang terbaik untuk mencapai nilai sasaran. * res - susunan input nilai perintang * num_res - ukuran susunan input nilai perintang * num_comb - bilangan perintang dibenarkan * indeks - indeks sisir * sisir - susunan gabungan semasa * sasaran - nilai sasaran * Tiada nilai pulangan - meneruskan kombinasi terbaik semasa ke nilai global * / fungsi resCombination (res, num_res, num_comb, index, comb, target) {// gabungan semasa selesai jika (index == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2 ^ (bilangan komponen) var ser_par = ; // array bool yang menentukan siri atau selari untuk setiap komponen var calc; // dikira nilai rintangan setara // melangkah ke setiap siri / konfigurasi selari kombinasi semasa untuk (var j = 0; j k) & 1; } // lakukan pengiraan untuk kombinasi berdasarkan kombo siri / selari untuk (var k = 0; k <num_comb; k ++) {// nombor pertama, tambah jika (k == 0) calc = comb [k]; // zero bermaksud seri, tambahkan nilai rintangan yang lain jika (! ser_par [k]) calc + = comb [k]; // satu bermaksud selari, kebalikan dari jumlah timbal balik yang lain jika (ser_par [k]) calc = (calc * comb [k]) / (calc + comb [k]); } // periksa untuk melihat apakah perbezaannya kurang daripada yang terbaik sebelumnya jika (Math.abs (calc - target) <terdekat_diff) {// itu kurang, jadi kemas kini nilai global terdekat_val = calc; terdekat_diff = Math.abs (calc - target); // kosongkan ke sifar untuk (var k = 0; k <num_comb; k ++) {terdekat [k] = 0; } // kemas kini nilai & susunan / susunan selari terdekat untuk (var k = 0; k <num_comb; k ++) {terdekat [k] = sisir [k]; ser_par_config [k] = ser_par [k]; }}} pulangkan 0; } // secara rekursif memanggil dan ganti indeks dengan semua nilai yang mungkin untuk (var i = 0; i = num_comb-index; i ++) {comb [index] = res ; resCombination (res, num_res, num_comb, index + 1, comb, target); }} / * Mengambil dan mencetak konfigurasi kapasitor terbaik * sasaran - nilai kapasitansi sasaran * numComp - jumlah kapasitor yang dibenarkan digunakan untuk mencapai sasaran val * compVals - susunan nilai kapasitor * / fungsi kapasitor (sasaran, numComp, compVals) {// panjang nilai kapasitans var num_cap = compVals.length; // jalankan semua kemungkinan komponen untuk (var i = 1; i <= numComp; i ++) {var data = ; capCombination (compVals, num_cap, i, 0, data, sasaran); } unit var = document.getElementById ("select_unit"). nilai; // hasil cetak outputStr = "Nilai terdekat:" + terdekat_val.toFixed (3) + "" + unit + ""; outputStr + = "Perbezaan:" + terdekat_diff.toFixed (3) + "" + unit + ""; outputStr + = "Konfigurasi Kapasitor:"; untuk (var i = 0; i <numComp; i ++) {if (i <terdekat.length) {outputStr + = "C" + i + "=" + terdekat + "" + unit + ""; if (i + 1 <terdekat.length) {if (ser_par_config [i + 1]) outputStr + = "||"; outputStr + = "+" yang lain; }} rehat yang lain; }} / * Mengira kombinasi kapasitor terbaik untuk mencapai nilai sasaran. * cap - array input nilai kapasitor * num_cap - ukuran array input nilai kapasitor * num_comb - bilangan kapasitor dibenarkan * indeks - indeks sisir * sisir - susunan kombinasi semasa * sasaran - nilai sasaran * Tiada nilai pulangan - meneruskan kombinasi terbaik semasa ke nilai global * / fungsi capCombination (cap, num_cap, num_comb, index, comb, target) {// gabungan semasa selesai jika (index == num_comb) {var ser_par_size = Math.pow (2, num_comb); // 2 ^ (bilangan komponen) var ser_par = ; // array bool yang menentukan siri atau selari untuk setiap komponen var calc; // nilai kapasitans setara yang dikira // melangkah ke setiap siri kemungkinan / konfigurasi selari kombinasi semasa untuk (var j = 0; j k) & 1; } // lakukan pengiraan untuk kombinasi berdasarkan kombo siri / selari untuk (var k = 0; k