Dasar · 11 mnt baca

Konversi nF ke µF: kode kapasitor dan satuan elektronika

Konversi nF ke µF jadi mudah: tabel pF-nF-µF, kode kapasitor 104 dan 2n2, kΩ, mA, mV, dan mAh ke Wh, plus kesalahan satuan yang sering muncul di kode Arduino dan ESP32.

Konversi nF ke µF bertumpu pada satu aturan: 1 µF = 1000 nF dan 1 nF = 1000 pF. Untuk berpindah dari nF ke µF kamu membagi dengan 1000, dan dari µF ke nF kamu mengalikan dengan 1000: 100 nF = 0,1 µF, 4,7 µF = 4700 nF. Angka 104 yang tercetak di kapasitor keramik berarti persis 100 nF itu juga, alias 0,1 µF. Hampir semua konversi satuan di elektronika berjalan dalam langkah kelipatan seribu seperti ini, jadi begitu awalannya kamu kuasai, hitungan resistor, arus, tegangan, dan baterai pun ikut jadi lebih mudah.

Di panduan ini kami merangkum awalan p, n, µ, m, k, dan M dalam satu tabel. Kamu akan belajar membaca kode kapasitor (104, 2n2, 474J), notasi 4K7 dan R47 pada resistor, cara berpindah antara mA dan A atau mV dan V, cara mengonversi kapasitas baterai dari mAh ke Wh, serta jalan pintas satuan yang membuatmu bisa menghitung hukum Ohm di luar kepala. Di bagian akhir kita akan melihat kesalahan satuan yang paling sering terjadi di kode Arduino, ESP32, dan Raspberry Pi Pico, beserta cara menulisnya dengan benar.

Kapasitor elektrolit bertanda 470 µF 16 V dan 220 µF 16 V
Pada kapasitor elektrolit, nilainya dicetak apa adanya (470 µF, 16 V); kapasitor keramik kecil memakai kode seperti 104.

Awalan SI: apa arti p, n, µ, m, k, dan M?

Nilai dalam elektronika mencakup rentang yang sangat lebar: arus sleep sebuah mikrokontroler hanya beberapa mikroampere sementara sebuah motor menarik beberapa ampere, dan kapasitor di samping kristal bisa bernilai 22 pikofarad sementara yang ada di output catu daya 2200 mikrofarad. Karena itulah kita memakai awalan alih-alih menulis deretan nol yang panjang. Setiap awalan mengalikan satuan dasar dengan pangkat 10 tertentu, dan awalan yang dipakai di elektronika semuanya berjarak 1000 kali satu sama lain. Aturannya sama untuk volt, ampere, ohm, farad, henry, watt, dan hertz.

AwalanSimbolPengaliContoh di elektronika
pikop10⁻¹² (0,000 000 000 001)Kapasitor beban kristal 22 pF
nanon10⁻⁹ (0,000 000 001)Kapasitor decoupling 100 nF, periode clock 62,5 ns
mikroµ (u)10⁻⁶ (0,000 001)Kapasitor 10 µF, arus sleep 10 µA
milim10⁻³ (0,001)Arus LED 20 mA, langkah ADC 4,88 mV
(satuan dasar)-15 V, 1 A, 1 Ω, 1 F
kilok10³ (1000)Resistor pull-up 10 kΩ, gelombang pembawa IR 38 kHz
megaM10⁶ (1 000 000)Resistansi input 1 MΩ, clock 16 MHz
gigaG10⁹Wi-Fi dan Bluetooth 2,4 GHz
Naik atau turun satu awalan berarti menggeser koma desimal tiga tempat. Berpindah dari satuan kecil ke yang lebih besar membuat angkanya mengecil (2200 pF = 2,2 nF); berpindah dari satuan besar ke yang lebih kecil membuatnya membesar (0,1 µF = 100 nF). Kalau keyboard-mu tidak punya µ, orang menulis u sebagai gantinya: 10uF sama dengan 10 µF.

Tabel konversi pF, nF, dan µF

Yang paling membingungkan dari kapasitor adalah nilai yang sama bisa ditulis dalam tiga satuan berbeda. Di skema tertulis 0,1 µF, di toko online tertulis 100 nF, di komponennya sendiri tertulis 104, padahal ketiganya kapasitor yang sama. Untuk mengonversi nF ke µF, bagi dengan 1000; untuk mengonversi pF ke nF, bagi lagi dengan 1000. Ke arah sebaliknya, kalikan dengan 1000. Tabel di bawah memuat nilai-nilai yang paling umum beserta kode yang akan kamu temukan tercetak di komponennya; layak dicetak dan ditempel di atas meja kerjamu.

pFnFµFKode
10 pF0,01 nF0,00001 µF100
22 pF0,022 nF0,000022 µF220
100 pF0,1 nF0,0001 µF101
1000 pF1 nF0,001 µF102
2200 pF2,2 nF (2n2)0,0022 µF222
4700 pF4,7 nF (4n7)0,0047 µF472
10.000 pF10 nF0,01 µF103
47.000 pF47 nF0,047 µF473
100.000 pF100 nF0,1 µF104
220.000 pF220 nF0,22 µF224
470.000 pF470 nF0,47 µF474
1.000.000 pF1000 nF1 µF105
10.000.000 pF10.000 nF10 µF106

Membaca kode kapasitor: 104 itu berapa nF?

Kapasitor keramik dan kapasitor film yang kecil tidak punya ruang untuk nilai lengkapnya, jadi yang dicetak adalah kode tiga digit, dan satuan kode itu selalu pikofarad. Dua digit pertama adalah nilainya, dan digit ketiga adalah jumlah nol yang ditambahkan di belakangnya. Untuk 104, taruh empat nol di belakang 10: 100.000 pF, yaitu 100 nF atau 0,1 µF. Kalau kamu malas menguraikannya di kepala, kalkulator kode kapasitor menyelesaikannya dalam sedetik; cara kerja kapasitor sendiri kami bahas di panduan Apa Itu Kapasitor?.

  1. Tulis dua digit pertama: 47 untuk 474.
  2. Tambahkan nol sebanyak angka di digit ketiga: 47 ditambah 4 nol menjadi 470.000 pF.
  3. Bagi dengan 1000 untuk mendapat nF: 470.000 pF = 470 nF.
  4. Bagi dengan 1000 sekali lagi untuk mendapat µF: 470 nF = 0,47 µF.
  5. Perhatikan huruf setelah kode: J berarti toleransi ±5%, K ±10%, dan M ±20%. 474J adalah kapasitor 0,47 µF dengan toleransi ±5%.
  6. Tanda seperti 2A atau 1H di depan kode menunjukkan rating tegangannya: 1H = 50 V, 2A = 100 V, 2J = 630 V.
Tulisan di kapasitorArtiNilai
2n2n menggantikan koma desimal2,2 nF = 2200 pF
4n7n menggantikan koma desimal4,7 nF = 4700 pF
µ1 atau u1µ menggantikan koma desimal0,1 µF = 100 nF
4µ7µ menggantikan koma desimal4,7 µF
p68p menggantikan koma desimal0,68 pF
109Digit ketiga 9 = ×0,11,0 pF
104ZZ = toleransi +80% / -20%100 nF
35 MFDNotasi lama: MFD = mikrofarad35 µF
Pada kapasitor lama dan kapasitor buatan Amerika, MFD dan bahkan mF dipakai dengan arti mikrofarad; tulisan “35 MFD” di kapasitor kipas plafon atau AC berarti 35 µF, bukan 35 milifarad. Begitu pula MMFD di skema lama berarti pikofarad. Ketika membeli komponen pengganti, baca satuannya sesuai konteks; kapasitor seukuran itu toh mustahil bernilai milifarad.

Satuan resistor: Ω, kΩ, MΩ, dan notasi 4K7

Satuan dasar resistor adalah ohm (Ω), tetapi sebagian besar nilai yang kamu temui di rangkaian Arduino ada di kisaran kiloohm: resistor LED 220 Ω, pull-up 10 kΩ, input impedansi tinggi 1 MΩ. Skema dan daftar komponen memakai huruf sebagai pengganti koma desimal, karena tanda sekecil itu bisa hilang di hasil cetakan sedangkan huruf tidak. R berarti ohm, K kiloohm, dan M megaohm, dan posisi huruf itulah letak koma desimalnya. Untuk menguraikan gelang warna di badan resistor, lihat panduan kode warna resistor atau kalkulator kode warna; untuk kode seperti 103 dan 4701 pada komponen SMD, baca kode resistor SMD.

NotasiNilaiDalam ohm
R470,47 Ω0,47 Ω
2R22,2 Ω2,2 Ω
220R220 Ω220 Ω
1K1 kΩ1000 Ω
4K74,7 kΩ4700 Ω
47K47 kΩ47.000 Ω
1M01 MΩ1.000.000 Ω
103 (SMD)10 ditambah 3 nol10.000 Ω = 10 kΩ
4701 (SMD, 4 digit)470 ditambah 1 nol4700 Ω = 4,7 kΩ

Kode tiga digit bekerja dengan cara yang sama pada resistor dan induktor, tetapi satuan dasarnya berubah: pikofarad pada kapasitor, ohm pada resistor SMD, dan mikrohenry pada induktor. Jadi 101 pada kapasitor berarti 100 pF, 101 pada resistor SMD berarti 100 Ω, dan 101 pada induktor berarti 100 µH. Jangan pernah menafsirkan sebuah kode tanpa tahu jenis komponen tempat kode itu tercetak.

Arus dan tegangan: konversi mA ke A, µA, dan mV ke V

Untuk arus, kamu paling sering bolak-balik antara mA dan A: 1 A = 1000 mA dan 1 mA = 1000 µA. LED yang menarik 20 mA berarti menarik 0,02 A; arus 10 µA yang ditarik ESP32 dalam deep sleep sama dengan 0,01 mA, atau 0,00001 A. Tegangan memakai jenjang yang sama: 1 V = 1000 mV. ADC 10-bit milik Arduino Uno membagi 5 V menjadi 1024 bagian, jadi tiap langkahnya 5 / 1024 = 0,00488 V, atau 4,88 mV. Datasheet sensor memberikan rasio seperti mV per derajat (10 mV/°C untuk LM35) atau mV per ampere (185 mV/A untuk ACS712-5A), dan memakai rasio itu dalam satuan yang benar menentukan seberapa akurat pengukuranmu. Pembacaan analog dibahas tuntas di Apa Itu ADC?.

SituasiNilai tipikalDalam satuan dasar
Arus pin Arduino Uno (disarankan / batas mutlak)20 mA / 40 mA0,02 A / 0,04 A
Arus kerja LED merah10-20 mA0,01-0,02 A
ESP32 ketika mengirim lewat Wi-Fihingga 250 mA0,25 A
Arus deep sleep chip ESP32sekitar 10 µA0,00001 A
Langkah ADC Arduino Uno (5 V, 10-bit)4,88 mV0,00488 V
Langkah ADC ESP32 dan Pico (3,3 V, 12-bit)sekitar 0,8 mV0,0008 V
Arus stall servo SG90650-700 mAsekitar 0,7 A

Jalan pintas satuan untuk hukum Ohm: V, mA, dan kΩ

Kamu tidak harus mengubah setiap nilai ke satuan dasar sebelum menghitung. Kalau awalannya kamu pasangkan sehingga saling menghilangkan, hasilnya langsung keluar dalam satuan yang benar. Pasangan yang paling praktis adalah ini: volt dibagi kiloohm menghasilkan miliampere. Beri 5 V pada resistor pull-up 10 kΩ, maka mengalir 5 / 10 = 0,5 mA, tanpa perlu repot dengan deretan nol. Dengan logika yang sama, miliampere kali kiloohm menghasilkan volt, dan volt kali miliampere menghasilkan miliwatt. Ini berlaku juga untuk waktu pengisian kapasitor: kiloohm kali mikrofarad menghasilkan milidetik. Untuk menyegarkan lagi dasarnya, baca Hukum Ohm, atau pakai kalkulator hukum Ohm untuk jawaban cepat.

RumusPasangan satuanContoh
I = V / RV / kΩ = mA5 V / 10 kΩ = 0,5 mA
R = V / IV / mA = kΩ(5 V - 2 V) / 20 mA = 0,15 kΩ = 150 Ω
V = I × RmA × kΩ = V2 mA × 4,7 kΩ = 9,4 V
P = V × IV × mA = mW5 V × 20 mA = 100 mW
τ = R × CkΩ × µF = ms10 kΩ × 100 µF = 1000 ms = 1 s
τ = R × CkΩ × nF = µs10 kΩ × 100 nF = 1000 µs = 1 ms
τ = R × CMΩ × µF = s1 MΩ × 10 µF = 10 s
Baris kedua di tabel itu sebenarnya adalah perhitungan resistor LED: kurangi 5 V dengan jatuh tegangan LED sebesar 2 V, bagi sisa 3 V dengan 20 mA, dan kamu mendapat 0,15 kΩ. Kalau nilai itu tidak ada di seri standar, pilih nilai berikutnya di atasnya (150 Ω atau 220 Ω). Untuk bereksperimen dengan konstanta waktu di rangkaian RC, coba kalkulator konstanta waktu RC.

mAh dan Wh: konversi kapasitas baterai

mAh (miliampere-jam) menunjukkan seberapa besar arus yang bisa diberikan sebuah baterai selama berapa jam, sedangkan Wh (watt-jam) menunjukkan berapa banyak energi yang benar-benar tersimpan di dalamnya. Kamu butuh Wh untuk membandingkan baterai dengan tegangan berbeda, karena baterai AA 2000 mAh dan sel litium 2000 mAh tidak menyimpan energi yang sama. Rumus konversinya sederhana: Wh = mAh × V / 1000. Sel 18650 berkapasitas 2600 mAh dengan tegangan 3,7 V menyimpan 2600 × 3,7 / 1000 = 9,62 Wh. Batas 100 Wh yang ditetapkan maskapai untuk power bank di bagasi kabin setara dengan kira-kira 27.000 mAh pada 3,7 V.

Untuk memperkirakan umur baterai, bagi kapasitasnya dengan arus rata-rata: jam = mAh / mA. Dalam praktik, baterai tidak bisa dipakai sampai habis total dan regulator membuang sebagian energi, jadi mengalikan hasilnya dengan 0,7-0,8 lebih realistis. Proyek ESP32 yang menarik rata-rata 80 mA akan berjalan sekitar 2600 / 80 × 0,8 = 26 jam dengan sel 2600 mAh. Angka 10.000 mAh yang tertera di power bank mengacu pada sel 3,7 V di dalamnya; setelah dinaikkan ke 5 V dengan efisiensi sekitar 85%, kapasitas yang bisa dipakai tinggal sekitar 10.000 × 3,7 × 0,85 / 5 ≈ 6300 mAh. Untuk hitungan lengkapnya, baca Apa Arti mAh? atau coba kalkulator umur baterai.

BateraiKapasitasTeganganEnergi
Baterai koin CR2032220 mAh3 V0,66 Wh
Alkaline AAsekitar 2500 mAh1,5 Vsekitar 3,75 Wh
Alkaline 9 Vsekitar 500 mAh9 Vsekitar 4,5 Wh
LiPo 1000 mAh1000 mAh3,7 V3,7 Wh
Li-ion 186502600 mAh3,7 V9,62 Wh
Power bank 10.000 mAh10.000 mAh3,7 V (sel)37 Wh

Waktu dan frekuensi: ms, µs, Hz, kHz, dan MHz

Frekuensi dan periode adalah kebalikan satu sama lain: T = 1 / f. Karena hertz berarti satu per detik, kebalikan kHz keluar dalam ms dan kebalikan MHz dalam µs. Motor servo dikendalikan pada 50 Hz, jadi sebuah pulsa datang setiap 1 / 50 = 0,02 s = 20 ms. Sebagian besar pin PWM di Arduino Uno bekerja pada sekitar 490 Hz dengan periode 2,04 ms; pin 5 dan 6 bekerja pada 980 Hz dengan periode 1,02 ms (selengkapnya di Apa Itu PWM?). Pada clock 16 MHz, satu siklus clock berlangsung 62,5 ns. Jangan pula tertukar antara dua fungsi waktu Arduino: millis() mengembalikan milidetik, micros() mengembalikan mikrodetik, dan delayMicroseconds() hanya akurat sampai 16.383 µs; untuk jeda yang lebih lama, pakai pengaturan waktu dengan millis().

Satuan kecepatan bertumpu pada konversi yang sama. Untuk sensor jarak HC-SR04, kecepatan suara adalah 343 m/s; kalau dikonversi ke cm/µs hasilnya 34.300 cm / 1.000.000 µs = 0,0343 cm/µs. Karena sensor melaporkan waktu tempuh gema pergi-pulang, jarak = waktu (µs) × 0,0343 / 2, sehingga gema 1000 µs berarti 17,15 cm. Begitu kamu tahu dari mana angka 0,0343 itu berasal, kamu bisa mencari sendiri faktor yang tepat ketika menginginkan hasil dalam meter atau inci.

Kesalahan satuan di kode Arduino: mengonversi pembacaan ADC ke mV dan V

Walaupun konversinya sudah benar di atas kertas, ada dua jebakan yang menunggu di dalam kode. Yang pertama adalah overflow int: di Arduino Uno sebuah int paling banyak menampung 32.767, padahal 1023 × 5000 adalah 5.115.000, sehingga hasilnya kacau. Yang kedua adalah pembagian bilangan bulat: 4700 / 1000 menghasilkan 4, bukan 4,7, karena membagi dua bilangan bulat membuang bagian pecahannya. Solusinya adalah melakukan perkalian sebagai long dan menulis 1000.0 alih-alih 1000 ketika kamu menginginkan hasil desimal. Sketch di bawah mengonversi tegangan di A0 ke mV dan V dengan benar, lalu menghitung tegangan input sebenarnya dari sebuah pembagi tegangan 10 kΩ dan 4,7 kΩ.

C++ (Arduino IDE)
1// ADC değerini mV ve V'a çevirme / Converting ADC readings to mV and V
2const int SENSOR_PIN = A0;
3const long VREF_MV = 5000;        // Uno referansı 5000 mV / Uno reference 5000 mV
4const float R1_KOHM = 10.0;       // üst direnç 10 kΩ / top resistor 10 kΩ
5const float R2_KOHM = 4.7;        // alt direnç 4,7 kΩ / bottom resistor 4.7 kΩ
6
7void setup() {
8  Serial.begin(9600);
9}
10
11void loop() {
12  int raw = analogRead(SENSOR_PIN);              // 0-1023
13
14  // YANLIŞ: int ile raw * 5000 taşar / WRONG: raw * 5000 overflows an int
15  // int wrongMv = raw * 5000 / 1024;
16
17  long mv = (long)raw * VREF_MV / 1024;          // doğru: long ile mV / correct: mV using long
18  float volts = mv / 1000.0;                     // mV -> V, 1000.0 ondalıklı böler / 1000.0 keeps decimals
19  float vin = volts * (R1_KOHM + R2_KOHM) / R2_KOHM;  // kΩ / kΩ birimsizdir / kΩ over kΩ is unitless
20
21  Serial.print("ham / raw: ");  Serial.print(raw);
22  Serial.print("  mV: ");       Serial.print(mv);
23  Serial.print("  V: ");        Serial.print(volts, 3);
24  Serial.print("  Vin: ");      Serial.println(vin, 2);
25  delay(500);
26}

Cast (long)raw membuat perkalian dilakukan dalam 32 bit, sehingga tidak ada yang overflow. Kita membagi dengan 1024 karena begitulah rumus di datasheet ATmega328P; selisihnya dengan 1023 hanya sekitar 0,1 persen. Menulis resistor pembagi dalam kΩ tidak masalah, karena satuannya saling menghilangkan di dalam rasio. Dengan pembagi ini, A0 paling tinggi menerima 5 V sementara di input kamu bisa mengukur sampai sekitar 15,6 V.

Pengurai kode kapasitor: ketik 104 di Serial Monitor

Supaya menguraikan kode terasa otomatis, mari kita tulis sebuah alat kecil. Program di bawah membaca kode tiga digit yang kamu ketik di Serial Monitor dan mencetak nilainya dalam pF, nF, dan µF. Program ini juga menangani kasus khusus ketika digit ketiganya 8 atau 9 (×0,01 dan ×0,1). Cukup atur akhir baris Serial Monitor ke “Newline”.

C++ (Arduino IDE)
1// Kondansatör kodu çözücü / Capacitor code decoder
2// Seri Monitör'e 104, 222, 475 gibi bir kod yaz / Type a code such as 104, 222 or 475
3
4void printValue(float pf) {
5  Serial.print(pf, 1);              Serial.print(F(" pF = "));
6  Serial.print(pf / 1000.0, 3);     Serial.print(F(" nF = "));
7  Serial.print(pf / 1000000.0, 6);  Serial.println(F(" uF"));
8}
9
10void setup() {
11  Serial.begin(9600);
12  Serial.println(F("Kod yaz (or. 104) / Type a code (e.g. 104)"));
13}
14
15void loop() {
16  if (!Serial.available()) return;
17  String code = Serial.readStringUntil('\n');
18  code.trim();
19
20  if (code.length() != 3 || !isDigit(code[0]) || !isDigit(code[1]) || !isDigit(code[2])) {
21    Serial.println(F("3 haneli kod yaz / Enter a 3-digit code"));
22    return;
23  }
24
25  int digits = (code[0] - '0') * 10 + (code[1] - '0');  // ilk iki hane / first two digits
26  int mult = code[2] - '0';                             // üçüncü hane / third digit
27  float pf = digits;
28
29  if (mult == 9) pf *= 0.1;          // 9 = ×0,1 / 9 means ×0.1
30  else if (mult == 8) pf *= 0.01;    // 8 = ×0,01 / 8 means ×0.01
31  else for (int i = 0; i < mult; i++) pf *= 10;  // sıfır ekle / append zeros
32
33  Serial.print(code); Serial.print(F(" -> "));
34  printValue(pf);
35}

Konversi satuan di ESP32 dan Raspberry Pi Pico

ADC milik ESP32 beresolusi 12-bit dan mengembalikan 0-4095, tetapi pinnya bekerja pada 3,3 V dan ADC-nya melenceng sedikit berbeda di setiap board. Karena itu lebih baik memakai fungsi analogReadMilliVolts() dari core ketimbang mengonversi nilai mentahnya sendiri: fungsi ini memakai kalibrasi yang ditanam ke chip di pabrik dan langsung mengembalikan milivolt. Dengan atenuasi bawaan 11 dB, rentang yang bisa diukur mencapai sekitar 3,1 V, dan hasil paling akurat ada di antara 0,15 dan 2,45 V.

C++ (Arduino IDE)
1// ESP32: ham ADC değeri ve kalibrasyonlu mV / raw ADC value and calibrated mV
2const int ADC_PIN = 34;   // yalnız giriş pini, ADC1 / input-only pin, ADC1
3
4void setup() {
5  Serial.begin(115200);
6  analogReadResolution(12);   // 0-4095
7}
8
9void loop() {
10  int raw = analogRead(ADC_PIN);
11  unsigned long mv = analogReadMilliVolts(ADC_PIN);   // fabrika kalibrasyonu / factory calibration
12  float volts = mv / 1000.0;                          // mV -> V
13  Serial.printf("ham/raw: %d  mV: %lu  V: %.3f\n", raw, mv, volts);
14  delay(500);
15}

Di Raspberry Pi Pico, read_u16() milik MicroPython menskalakan nilainya ke 0-65535 meskipun ADC-nya 12-bit. Jadi faktor konversinya harus 3.3 / 65535, bukan 3.3 / 4095; memakai faktor yang salah membuat hasilmu 16 kali terlalu besar. Resolusi sebenarnya tetap 3,3 V / 4096 ≈ 0,8 mV.

MicroPython
1# Pico: ADC değerini mV ve V'a çevirme / converting ADC readings to mV and V
2from machine import ADC
3import time
4
5adc = ADC(26)              # GP26 = ADC0
6CONV = 3.3 / 65535         # read_u16() 0-65535 aralığı / range of read_u16()
7
8while True:
9    raw = adc.read_u16()
10    volts = raw * CONV
11    mv = volts * 1000      # V -> mV
12    print("ham/raw:", raw, " mV:", round(mv), " V:", round(volts, 3))
13    time.sleep(0.5)

Kesalahan satuan yang umum dan cara memperbaikinya

  • Tertukar antara m dan M: 1 mΩ (miliohm) dan 1 MΩ (megaohm) berbeda satu miliar kali. Huruf kecil m berarti mili, huruf besar M berarti mega, jadi perhatikan besar-kecilnya huruf di skema.
  • Membaca 104 sebagai 104 pF: digit ketiga adalah jumlah nol, jadi nilainya 100.000 pF. Hanya tulisan dua digit seperti 22 dan 47 yang langsung berarti pikofarad; pada kode tiga digit, 220 pun berarti 22 pF, bukan 220 pF.
  • Membandingkan mAh pada tegangan yang berbeda: konversikan ke Wh ketika membandingkan baterai dengan tegangan berbeda; kalau tidak, baterai 9 V akan tampak lebih lemah dan baterai AA lebih kuat daripada kenyataannya.
  • Pembagian bilangan bulat: di Arduino, 3 / 2 hasilnya 1. Kalau butuh hasil desimal, tulis salah satu angkanya sebagai desimal seperti 3.0, atau pakai float.
  • Overflow int: hasil kali seperti analogRead() × 5000 melampaui batas 32.767 milik Uno. Lakukan cast ke (long) sebelum mengalikan.
  • Tertukar antara W dan Wh: W adalah daya seketika, sedangkan Wh adalah energi yang terpakai ketika daya itu bekerja selama satu jam. Rangkaian yang menarik 2 W berjalan 5 jam dengan baterai 10 Wh, jika rugi-rugi diabaikan.
  • Melupakan daya resistor: 1/4 W berarti 250 mW. Resistor 100 Ω yang diberi 12 V membuang 1,44 W dan akan menghanguskan resistor seperempat watt standar, jadi selalu lakukan perhitungan daya.
Ketika sebuah hasil tampak mencurigakan, tulis satuannya di samping angka lalu sederhanakan. Kalau satuan yang keluar bukan yang kamu harapkan (mA, ms, Wh), ada awalan yang terlewat di suatu tempat dalam rumus. Kebiasaan ini menangkap sebagian besar kesalahan selagi masih di atas kertas, baik ketika ujian maupun di meja kerja.

Begitu awalan dan jalan pintas satuan sudah di luar kepala, membaca datasheet, memilih komponen, dan menulis faktor yang tepat di kode jadi jauh lebih cepat. Kalau kamu ingin mempraktikkannya, proyek voltmeter digital LCD, pembacaan tingkat cahaya dengan LDR, pengukuran suhu dengan NTC, dan deep sleep ESP32 di aplikasi BlueGrays menunjukkan langkah demi langkah, lengkap dengan skema rangkaian dan kode, bagaimana nilai ADC, arus, dan umur baterai dihitung.

Pertanyaan umum

Berapa nilai kapasitor 104 dalam nF?

Kode 104 dibaca sebagai 10 diikuti empat nol: 100.000 pF. Itu sama dengan 100 nF atau 0,1 µF. Inilah kapasitor decoupling yang akan kamu temukan di jalur catu daya sebagian besar rangkaian Arduino.

1 µF sama dengan berapa nF?

1 µF sama dengan 1000 nF. Untuk mengonversi nF ke µF, bagi dengan 1000; misalnya 470 nF = 0,47 µF dan 22 nF = 0,022 µF.

Apa arti 2n2 pada kapasitor?

Pada 2n2, huruf n menandai satuannya (nanofarad) sekaligus letak koma desimalnya, jadi nilainya 2,2 nF, atau 2200 pF. Kapasitor yang sama bisa juga ditandai dengan kode tiga digit 222.

Apa kode untuk kapasitor 10 µF?

10 µF adalah 10.000.000 pF, yaitu 10 diikuti enam nol, jadi kode tiga digitnya 106. Kapasitor elektrolit biasanya tidak memakai kode dan langsung mencetak 10 µF apa adanya, bersama rating tegangannya.

Bagaimana cara mengonversi mAh ke Wh?

Kalikan nilai mAh dengan tegangan nominal baterai lalu bagi dengan 1000: Wh = mAh × V / 1000. Sel 18650 dengan 3,7 V dan 2600 mAh menyimpan energi sekitar 9,6 Wh.

Apakah MFD sama dengan µF?

Ya. MFD adalah notasi lama untuk mikrofarad, jadi kapasitor bertanda 35 MFD di AC, kipas angin, atau motor berarti 35 µF. Tanda sejenisnya, MMFD, berarti pikofarad.

Lihat semua proyek
Mengukur Intensitas Cahaya dengan LDR
AR-11Pemula

Mengukur Intensitas Cahaya dengan LDR

Ingin melihat seberapa terang kamarmu dalam bentuk angka? LDR, komponen kecil yang bereaksi terhadap cahaya, mengukur cahaya di sekitarnya, dan Arduino menulis nilainya ke layar komputermu setiap…

4.6(83)
143
Membaca Intensitas Cahaya dengan Modul LDR ESP32
ES-11Pemula

Membaca Intensitas Cahaya dengan Modul LDR ESP32

Memantau secara real-time di Serial Monitor nilai ADC mentah modul LDR dan persentase cahaya relatif yang dihitung dari nilai acuan gelap dan terang. Persentase ini bukan pengukuran lux. Mengajarkan logika kalibrasi modul. Ideal dikerjakan sebelum Proyek 10, karena dipakai untuk menentukan nilai ambang.

4.6(36)
55
Pengukuran Jarak HC-SR04 (Tampilan Serial)
AR-27Pemula

Pengukuran Jarak HC-SR04 (Tampilan Serial)

Sensor HC-SR04 bekerja persis seperti kelelawar yang mencari jalan dalam gelap: ia mengirim suara yang tidak bisa kamu dengar, mendengarkan pantulannya, dan mengukur seberapa jauh benda di depannya.

4.6(50)
82
Voltmeter Digital dengan Layar LCD
AR-56Menengah
Premium

Voltmeter Digital dengan Layar LCD

Cari tahu berapa tegangan yang diberikan baterai atau adaptor daya dengan alat ukur buatanmu sendiri.

4.5(27)
36
Mengukur Suhu dengan NTC dan Layar LCD 2x16
AR-44Pemula
Premium

Mengukur Suhu dengan NTC dan Layar LCD 2x16

Ukur suhu di sekitarmu dengan sensor yang mirip manik-manik kecil. Komponen bernama NTC ini makin mudah dilewati listrik ketika makin hangat; Arduino membaca perubahan itu, mengubahnya menjadi…

4.5(33)
44
Kendali Kecerahan LED dengan Potensiometer ESP32 (Analog → PWM)
ES-13Menengah
Premium

Kendali Kecerahan LED dengan Potensiometer ESP32 (Analog → PWM)

Di proyek ini, kita mengendalikan kecerahan LED secara analog memakai potensiometer. Pin ADC ESP32 membaca tegangan 0-3,3V dari potensiometer, lalu nilai ini diubah menjadi sinyal PWM (Pulse Width Modulation) dan dikirim ke LED. Hasilnya, ketika kamu memutar potensiometer, LED perlahan menerang dan meredup. Dengan Arduino Core 3.0+, analogWrite() bisa langsung dipakai; di ESP32-S2/S3, resolusi ADC tetap 12-bit.

4.5(19)
32
Deep Sleep ESP32: Hemat Baterai (OLED + Penghitung RTC RAM)
ES-33Mahir
Premium

Deep Sleep ESP32: Hemat Baterai (OLED + Penghitung RTC RAM)

Mode Deep Sleep ESP32 menurunkan konsumsi arus hingga ~10 µA dengan mematikan CPU dan sebagian besar periferal, sehingga sangat penting untuk perangkat IoT bertenaga baterai. Di proyek ini, kita memakai tiga sumber bangun yang berbeda: timer (15 detik), pin eksternal (EXT0, tombol GPIO 33), dan sentuhan (T0/GPIO 4). Variabel yang ditandai RTC_DATA_ATTR dipertahankan selama deep sleep; penghitung boot, penghitung bangun karena timer, dan penghitung bangun karena tombol terus dilacak.

4.3(10)
16
Mengatur Frekuensi Buzzer
AR-14Menengah

Mengatur Frekuensi Buzzer

Kamu mengendalikan suara buzzer dengan empat tombol: satu memulai suara, satu membungkamnya, dan dua lainnya membuatnya lebih tinggi atau lebih rendah.

4.6(69)
120