Pembagi Tegangan: Rumus, Memilih Resistor, dan Contoh Arduino

Pembagi tegangan (voltage divider) adalah rangkaian paling sederhana untuk mengubah sebuah tegangan menjadi tegangan yang lebih kecil dan bisa diprediksi, memakai dua resistor yang disusun seri. Tegangan output-nya dihitung dengan Vout = Vin × R2 / (R1 + R2): R1 terhubung ke sumber, R2 terhubung ke ground (GND), dan output diambil dari titik tengah tempat keduanya bertemu. Misalnya, dua resistor 10 kΩ membagi 12 V tepat menjadi setengahnya, yaitu 6 V. Dua resistor ini ada di jantung banyak sekali rangkaian, mulai dari mengukur baterai 12 V dengan Arduino dan menurunkan sinyal sensor 5 V ke pin 3,3 V milik ESP32, sampai membaca sensor seperti LDR dan termistor NTC.

Di panduan ini kamu akan melihat, dengan angka sungguhan, dari mana rumusnya berasal, bagaimana memilih nilai resistornya, dan kenapa output-nya turun ketika kamu menyambungkan sesuatu ke pembagi (efek pembebanan). Setelah itu, langkah demi langkah, kita akan membuat kode untuk mengukur tegangan baterai dengan Arduino Uno, ESP32, dan Raspberry Pi Pico, memilih pasangan resistor yang tepat untuk mengubah 5 V menjadi 3,3 V, serta membaca LDR dan NTC dengan pembagi tegangan. Terakhir, kita akan menjelaskan kenapa pembagi tegangan tidak boleh dipakai sebagai pengganti catu daya.

Apa itu pembagi tegangan dan bagaimana cara kerjanya?

Rumus pembagi tegangan langsung berasal dari Hukum Ohm. Arus yang sama mengalir melalui R1 dan R2, yang terhubung seri antara sumber dan ground: I = Vin / (R1 + R2). Tegangan pada R2, yaitu output-nya, adalah arus tersebut dikali R2: Vout = I × R2 = Vin × R2 / (R1 + R2). Singkatnya, tegangan sumber dibagi di antara resistor sebanding dengan nilainya; resistor yang lebih besar mendapat bagian yang lebih besar. Output selalu lebih kecil daripada input, karena rasio R2 / (R1 + R2) kurang dari 1. Penjelasan lebih lengkap tentang pembagian tegangan di rangkaian seri ada di Resistor Seri dan Paralel.

Kamu juga bisa menghitung dari arah sebaliknya: kalau ingin menurunkan 12 V menjadi 3,3 V dan sudah memilih 10 kΩ untuk R2, kamu mendapat R1 = 10 × (12 / 3,3 − 1) ≈ 26,4 kΩ. Nilai itu tidak dijual, jadi kamu memilih nilai standar berikutnya yang lebih besar, yaitu 27 kΩ, dan output-nya menjadi 12 × 10 / 37 ≈ 3,24 V. Membulatkan R1 ke atas sedikit menurunkan output, dan itu sisi yang aman untuk pin. Potensiometer sebenarnya juga pembagi tegangan yang bisa diatur: wiper-nya membagi jalur resistifnya menjadi R1 dan R2. Kalau tidak mau menghitung manual, kalkulator pembagi tegangan langsung memberimu output dari tegangan input dan resistornya. Dalam elektronika, kamu paling sering melihat pembagi tegangan melakukan tugas-tugas ini:

• Mengukur tegangan yang lebih tinggi: menurunkan sumber seperti baterai 12 V atau pack lithium 7,4 V ke rentang yang bisa diukur input analog.
• Menurunkan level sinyal: membuat sinyal 5 V aman untuk input 3,3 V milik ESP32 atau Raspberry Pi Pico.
• Membaca sensor resistif: mengubah perubahan hambatan komponen seperti LDR, NTC, sensor flex, dan sensor gaya (FSR) menjadi tegangan.
• Membaca banyak tombol di satu pin: tangga resistor memberi setiap tombol tegangan yang berbeda, sehingga lima tombol bisa berbagi satu pin analog.
• Umpan balik regulator: regulator seperti LM317 dan LM2596 versi adjustable menjaga output-nya tetap stabil dengan mengukurnya lewat pembagi tegangan; untuk LM317, Vout = 1,25 × (1 + R2 / R1).
• Membuat tegangan referensi: menghasilkan setengah tegangan catu sebagai referensi di rangkaian op-amp.

Cara memilih nilai resistor

Rumusnya hanya peduli pada rasio: 1 kΩ + 1 kΩ dan 100 kΩ + 100 kΩ membagi dengan besar yang sama, tepat setengahnya. Namun dalam praktik, nilai mutlaknya juga penting. Resistor kecil membuat banyak arus mengalir melalui pembagi; arus itu adalah energi yang terbuang dan menguras baterai dengan percuma di proyek bertenaga baterai. Resistor besar menarik arus yang sangat kecil, tetapi output-nya lemah: beban yang disambungkan atau kapasitor sampling di dalam input analog dengan mudah mengganggu tegangan output, dan derau yang tertangkap kabel juga lebih mudah masuk. Pilihan yang tepat adalah keseimbangan di antara dua ekstrem ini:

1. Tentukan tegangan input tertinggi. Aki asam timbal 12 V bisa mencapai 14,4 V ketika diisi; ambil kondisi terburuk dari tegangan yang akan kamu ukur lalu tambahkan margin 10%.
2. Tentukan tegangan tertinggi yang diterima pin. 5 V di Arduino Uno, 3,3 V di ESP32 dan Pico; sebagai target aman, pilih sekitar 4,5 V di Uno, 2,5 V di ESP32, dan 3,0 V di Pico.
3. Hitung rasionya: k = output target / input tertinggi. Misalnya, 4,5 / 14,4 ≈ 0,31.
4. Pilih R2 (10 kΩ adalah titik awal yang bagus di kebanyakan kasus) lalu cari R1 dengan R1 = R2 × (1 / k − 1). Bulatkan hasilnya ke atas ke nilai berikutnya di antara nilai standar resistor.
5. Cek arus dan dayanya: I = Vin / (R1 + R2) dan P = Vin² / (R1 + R2). Di proyek baterai, usahakan arusnya tetap di kisaran mikroampere.
6. Cek hambatan output-nya: R1 × R2 / (R1 + R2) sebaiknya di bawah 10 kΩ untuk Arduino Uno; kalau tidak, tambahkan kapasitor 100 nF antara pin analog dan GND.
7. Masukkan rasio yang sebenarnya ke kodemu: hitung ulang rasionya dengan nilai standar yang kamu pilih, lalu ukur dengan multimeter setelah rangkaiannya jadi dan lakukan kalibrasi.

Efek pembebanan: apa yang terjadi ketika kamu menyambungkan sesuatu ke pembagi?

Rumus tadi mengasumsikan tidak ada arus yang ditarik dari output. Begitu kamu menyambungkan beban, beban itu menjadi paralel dengan R2, hambatan ekuivalen kaki bawah mengecil, dan tegangan output turun. Cara mudah menghitungnya adalah memperlakukan pembagi sebagai ekuivalen Thevenin-nya: sebuah sumber dengan tegangan yang kamu ukur tanpa beban (Vth) dan hambatan dalam Rth = R1 × R2 / (R1 + R2). Dengan beban RL, output-nya menjadi Vth × RL / (Rth + RL). Tabel di bawah menunjukkan sumber 10 V yang dibagi dengan 10 kΩ + 10 kΩ (Vth = 5 V, Rth = 5 kΩ) dengan beban yang berbeda-beda di output:

Patokan praktisnya: kalau hambatan beban setidaknya 100 kali hambatan output pembagi (Rth), error-nya tetap di bawah 1%. Kalau bebannya lebih kecil, kecilkan resistornya atau pasang voltage follower (buffer) op-amp di antaranya. Input analog mikrokontroler sendiri punya hambatan yang sangat tinggi, tetapi di dalamnya ada kapasitor sampling kecil yang diisi setiap kali konversi (sekitar 14 pF di ATmega328P). Karena itulah datasheet menyarankan hambatan output sumber sekitar 10 kΩ atau kurang. Kalau kamu memakai pembagi bernilai lebih tinggi, tambahkan kapasitor 100 nF antara pin analog dan GND: kapasitor ini menyiapkan muatan yang dibutuhkan pada momen sampling. Dan kalau kamu membaca beberapa pin analog bergantian, membuang pembacaan pertama di setiap pin akan menghilangkan error sisa dari perpindahan kanal.

Kenapa pembagi tegangan tidak bisa dipakai sebagai catu daya

Jebakan pemula yang paling umum adalah mengambil 5 V dari adaptor 12 V dengan dua resistor lalu mencoba memberi daya ke Arduino atau modul dari situ. Di atas kertas, pembagi 7 kΩ dan 5 kΩ memberi tepat 5 V dari 12 V, tetapi hanya selama tidak ada arus yang ditarik dari output. Board yang menarik 50 mA berperilaku seperti beban sekitar 100 Ω; ketika paralel dengan R2 yang 5 kΩ, kaki bawah turun menjadi 98 Ω dan output-nya anjlok ke 0,17 V. Kalau resistornya kamu kecilkan menjadi 70 Ω dan 50 Ω, rangkaiannya sekarang menarik 100 mA dan mengubah 1,2 W menjadi panas meskipun tidak ada apa pun yang tersambung; dengan beban terpasang, output-nya tetap merosot ke 3,9 V, dan setiap kali arus board berubah (Wi-Fi, servo, relay), tegangannya ikut berubah. Lebih parah lagi, ketika beban dilepas, tegangannya naik lagi dan bisa merusak komponen yang sensitif.

Mengukur tegangan aki 12 V dan baterai dengan Arduino

Input analog Arduino Uno hanya bisa membaca maksimal 5 V; menyambungkan aki 12 V secara langsung akan merusak pin-nya. Solusinya adalah pembagi 22 kΩ (R1) dan 10 kΩ (R2): dengan rasio 0,3125, tegangan pengisian 14,4 V sampai di pin sebagai 4,5 V, dan rangkaiannya bisa mengukur sampai 16 V. Pada 12 V, pembagi ini hanya menarik 0,375 mA, dan hambatan output-nya yang 6,9 kΩ berada di bawah batas 10 kΩ yang disarankan. ADC 10-bit membedakan sekitar 4,9 mV per langkah; dengan pembagi ini, resolusinya menjadi sekitar 15,6 mV di sisi input. Karena ESP32 dan Pico bekerja di 3,3 V, kita memakai R1 yang lebih besar (56 kΩ) di kedua board itu:

1// 12 V akü gerilimini gerilim bölücüyle ölçme / Measuring a 12 V battery with a voltage divider
2// Kaynak + -> 22k (R1) -> A0 -> 10k (R2) -> GND / Source + -> 22k (R1) -> A0 -> 10k (R2) -> GND
3// Kaynağın eksisi Arduino GND'sine bağlı / Source minus is tied to the Arduino GND
4const int VIN_PIN = A0;
5const float VREF = 5.0;      // 5V pininde ölçtüğün gerilim / voltage you measured on the 5V pin
6const float R1 = 22000.0;    // üst direnç (ohm) / top resistor (ohms)
7const float R2 = 10000.0;    // alt direnç (ohm) / bottom resistor (ohms)
8const float CAL = 1.000;     // kalibrasyon: gerçek / okunan / calibration: real / measured
9const float LOW_V = 11.8;    // düşük akü eşiği (V) / low battery threshold (V)
10
11float readInputVoltage() {
12  analogRead(VIN_PIN);                        // ilk okumayı at / discard the first reading
13  long sum = 0;
14  for (int i = 0; i < 16; i++) {              // 16 ölçümün ortalaması / average of 16 readings
15    sum += analogRead(VIN_PIN);
16    delay(2);
17  }
18  float vPin = (sum / 16.0) * VREF / 1024.0;  // pindeki gerilim / voltage at the pin
19  return vPin * (R1 + R2) / R2 * CAL;         // bölücüden önceki gerilim / voltage before the divider
20}
21
22void setup() {
23  Serial.begin(9600);
24  pinMode(LED_BUILTIN, OUTPUT);
25}
26
27void loop() {
28  float v = readInputVoltage();
29  Serial.print(F("Giris / Input: "));
30  Serial.print(v, 2);
31  Serial.println(F(" V"));
32  digitalWrite(LED_BUILTIN, v < LOW_V ? HIGH : LOW);  // akü zayıfsa LED yanar / LED on when the battery is low
33  delay(1000);
34}

Kode membuang pembacaan pertama supaya kapasitor sampling ADC sempat stabil, lalu merata-ratakan 16 pembacaan untuk mengurangi derau. Angka yang dibaca pertama-tama diubah menjadi tegangan pin (kita membagi dengan 1024 karena datasheet ATmega328P memberi ADC = Vin × 1024 / Vref), lalu dikalikan (R1 + R2) / R2 = 3,2 untuk mendapatkan tegangan sebelum pembagi. Sumber error terbesar adalah Vref: pin 5V pada Uno yang diberi daya lewat USB sering berada di mana saja antara 4,7 dan 5,1 V. Jadi ukur pin 5V dengan multimeter dan masukkan nilainya ke VREF; lalu ukur tegangan asli baterai dengan multimeter, bandingkan dengan nilai di Serial Monitor, dan masukkan CAL = asli / terukur di kode. Satu langkah ini mengoreksi error Vref dan toleransi resistor sekaligus. Kalau kamu menyambungkan pembagi setelah saklar on/off perangkat, pembagi tidak menarik arus ketika perangkat mati; 0,375 mA berarti sekitar 9 mAh sehari, yang tidak ada artinya untuk aki mobil tetapi cukup terasa untuk baterai kecil. Pasangan resistor yang cocok untuk sumber lain:

Mengukur tegangan dengan ESP32

Di ESP32, ADC-nya 12-bit (0–4095), tetapi ada dua perbedaan penting. Pertama, pin ADC2 tidak bisa dibaca selama Wi-Fi menyala, jadi selalu sambungkan pembagi ke salah satu pin ADC1, yaitu GPIO 32–39 (GPIO 34–39 hanya bisa input dan ideal untuk tugas ini). Kedua, ADC-nya tidak linear di ujung-ujung rentang: dengan atenuasi default 11 dB, Espressif menyarankan kira-kira 150–2450 mV sebagai rentang paling akurat. Pin akan menunjukkan nilai sampai sekitar 3,1 V, tetapi error-nya membesar di daerah itu. Karena itulah kita memilih pembagi 56 kΩ + 10 kΩ: 14,4 V sampai di pin sebagai 2,18 V dan tetap berada di rentang akurat. Alih-alih analogRead() mentah, kita memakai analogReadMilliVolts(), yang langsung mengembalikan milivolt dengan memakai data kalibrasi yang ditulis ke chip di pabrik:

1// ESP32: 56k + 10k bölücüyle 12 V ölçme / ESP32: measuring 12 V with a 56k + 10k divider
2const int VIN_PIN = 34;        // ADC1_CH6, Wi-Fi açıkken de çalışır / ADC1_CH6, works with Wi-Fi on
3const float R1 = 56000.0;      // üst direnç (ohm) / top resistor (ohms)
4const float R2 = 10000.0;      // alt direnç (ohm) / bottom resistor (ohms)
5const float CAL = 1.000;       // multimetreyle ayarla / tune with a multimeter
6
7void setup() {
8  Serial.begin(115200);
9  analogReadResolution(12);    // 0-4095 (varsayılan / default)
10}
11
12void loop() {
13  uint32_t mv = 0;
14  for (int i = 0; i < 32; i++) {
15    mv += analogReadMilliVolts(VIN_PIN);     // kalibre edilmiş milivolt / calibrated millivolts
16  }
17  float vPin = mv / 32.0 / 1000.0;           // pindeki gerilim (V) / voltage at the pin (V)
18  float vIn = vPin * (R1 + R2) / R2 * CAL;   // bölücüden önceki gerilim / voltage before the divider
19  Serial.printf("Pin: %.3f V  Giris / Input: %.2f V\n", vPin, vIn);
20  delay(1000);
21}

Mengukur tegangan dengan Raspberry Pi Pico (MicroPython)

Di Raspberry Pi Pico, input analognya adalah GP26, GP27, dan GP28 (ADC0–ADC2). read_u16() di MicroPython menskalakan pembacaan 12-bit ke rentang 0–65535, dan referensinya adalah ADC_VREF, yang berasal dari 3,3 V milik board. Karena ADC Pico bisa mengukur sampai 3,3 V, pembagi 56 kΩ + 10 kΩ membawamu sampai sekitar 21 V. Detail yang menarik: Pico sendiri memakai pembagi tegangan. Pembagi di board membagi tegangan catu VSYS dengan tiga lalu mengirimkannya ke GP29 (ADC3); kalikan tegangan yang kamu baca dengan ADC(29) dengan 3 dan kamu akan melihat tegangan catu board (di Pico W, GP29 dipakai bersama chip nirkabel, jadi cara ini tidak langsung jalan).

1from machine import ADC
2import time
3
4adc = ADC(26)            # GP26 = ADC0 (pin 31)
5VREF = 3.3               # ADC_VREF; multimetreyle ölçüp düzelt / measure and correct with a multimeter
6R1 = 56000               # üst direnç (ohm) / top resistor (ohms)
7R2 = 10000               # alt direnç (ohm) / bottom resistor (ohms)
8CAL = 1.000              # kalibrasyon katsayısı / calibration factor
9
10
11def read_input_voltage(samples=32):
12    total = 0
13    for _ in range(samples):
14        total += adc.read_u16()                  # 0-65535
15    v_pin = total / samples * VREF / 65535       # pindeki gerilim / voltage at the pin
16    return v_pin * (R1 + R2) / R2 * CAL          # bölücüden önceki gerilim / voltage before the divider
17
18
19while True:
20    v_in = read_input_voltage()
21    print("Giris / Input: {:.2f} V".format(v_in))
22    time.sleep(1)

Menurunkan sinyal 5 V menjadi 3,3 V (untuk ESP32 dan Pico)

Pin ESP32 dan Pico tidak tahan 5 V. Kalau output ECHO dari HC-SR04, pin TX Arduino Uno, atau output digital modul yang diberi daya 5 V disambungkan langsung ke board ini, dioda proteksi input-nya terbebani berlebihan dan pin-nya bisa rusak seiring waktu. Untuk sinyal satu arah, solusi termurahnya adalah pembagi tegangan. Tujuannya adalah tegangan yang tidak pernah melebihi 3,3 V tetapi tetap cukup tinggi untuk dibaca board sebagai HIGH: ESP32 menganggap 75% dari tegangan catunya (sekitar 2,5 V) sebagai level HIGH minimum, dan RP2040 di Pico memakai 2,0 V. Jadi output antara 3,0 dan 3,3 V memberi margin yang lega di kedua board. Ini juga cara yang disarankan di panduan sensor jarak HC-SR04 untuk menyambungkan pin ECHO ke board 3,3 V.

Bersama kapasitansi pin itu sendiri, pembagi tegangan membentuk filter RC kecil. Hambatan output 6,7 kΩ dari pembagi 10 kΩ + 20 kΩ dan sekitar 15 pF kapasitansi pin dan breadboard menghasilkan konstanta waktu sekitar 100 ns; UART 115200 baud (8,7 µs per bit) tidak terpengaruh, tetapi tepi sinyal SPI di beberapa MHz jadi tumpul. Di jalur cepat, pilih 1 kΩ + 2 kΩ. Ingat juga bahwa pembagi hanya bekerja satu arah, dari tegangan yang lebih tinggi ke yang lebih rendah. Untuk arah sebaliknya biasanya kamu tidak butuh apa-apa: Arduino Uno menganggap apa pun di atas 3,0 V sebagai HIGH, jadi ia bisa membaca output 3,3 V dari ESP32, meskipun dengan margin yang tipis. Namun di jalur dua arah seperti I2C, pembagi tidak berguna; di sana kamu memakai konverter level logika berbasis MOSFET.

Membaca LDR dan NTC dengan pembagi tegangan

Mikrokontroler tidak bisa mengukur hambatan secara langsung, hanya tegangan. Ketika kamu memasang sensor resistif seperti LDR atau NTC secara seri dengan resistor tetap sehingga membentuk pembagi tegangan, perubahan hambatan menjadi perubahan tegangan di titik tengah. Nilai resistor tetap menentukan sensitivitasnya. Untuk mendapatkan ayunan tegangan terbesar, resistor tetap sebaiknya bernilai rata-rata geometris dari hambatan terkecil dan terbesar sensor di rentang yang kamu pedulikan: R = √(Rmin × Rmax). Untuk LDR yang terbaca 1 kΩ di cahaya terang dan 100 kΩ di cahaya redup, hasilnya √(1 k × 100 k) = 10 kΩ. Pada 5 V, dengan 10 kΩ output-nya berayun sejauh 4,09 V, sedangkan dengan 1 kΩ atau 100 kΩ ayunannya menyusut menjadi 2,45 V. Karena itulah starter kit dilengkapi resistor 10 kΩ. Ada bonus lain: karena pembagi dan ADC sama-sama jalan dari 5 V yang sama, hambatan yang dihitung tidak bergantung pada tegangan catu (pengukuran rasiometrik), jadi kode di bawah bahkan tidak butuh nilai Vref.

1// LDR ve NTC'yi gerilim bölücüyle okuma / Reading an LDR and an NTC with voltage dividers
2// A0: 5V -> LDR -> A0 -> 10k -> GND
3// A1: 5V -> 10k -> A1 -> NTC 10k (B = 3950) -> GND
4const float R_FIXED = 10000.0;  // sabit dirençler (ohm) / fixed resistors (ohms)
5const float R0 = 10000.0;       // NTC'nin 25 °C direnci / NTC resistance at 25 °C
6const float BETA = 3950.0;      // NTC B katsayısı / NTC beta coefficient
7const float T0 = 298.15;        // 25 °C kelvin cinsinden / 25 °C in kelvin
8
9void setup() {
10  Serial.begin(9600);
11}
12
13void loop() {
14  analogRead(A0);                         // kanal değişti, ilk okumayı at / channel changed, discard first reading
15  int ldrRaw = analogRead(A0);
16  analogRead(A1);
17  int ntcRaw = analogRead(A1);
18  if (ldrRaw < 1) ldrRaw = 1;             // sıfıra bölmeyi önle / avoid division by zero
19
20  // Oransal ölçüm: besleme gerilimi hesaptan düşer / ratiometric: the supply voltage cancels out
21  float rLdr = R_FIXED * (1024.0 / ldrRaw - 1.0);
22  float rNtc = R_FIXED * ntcRaw / (1024.0 - ntcRaw);
23  float tempC = 1.0 / (1.0 / T0 + log(rNtc / R0) / BETA) - 273.15;  // Beta denklemi / Beta equation
24
25  Serial.print(F("LDR: "));
26  Serial.print(rLdr / 1000.0, 1);
27  Serial.print(F(" kOhm   NTC: "));
28  Serial.print(rNtc / 1000.0, 2);
29  Serial.print(F(" kOhm   "));
30  Serial.print(tempC, 1);
31  Serial.println(F(" C"));
32  delay(1000);
33}

Di kode, LDR berada di atas, jadi pembacaannya naik ketika cahaya makin terang; hambatannya R = 10 kΩ × (1024 / ADC − 1). NTC berada di bawah, dan ketika suhu naik, hambatannya, dan otomatis tegangan yang terbaca, turun. Untuk NTC umum yang bernilai 10 kΩ pada 25 °C dengan koefisien B 3950, suhunya didapat dari persamaan Beta: 1 / T = 1 / T0 + ln(R / R0) / B (suhu dalam kelvin). Karena resistor tetap sama dengan hambatan NTC pada 25 °C, output pada suhu ruangan tepat setengah tegangan catu, di titik sensitivitasnya paling tinggi. Untuk akurasi yang lebih baik di rentang suhu yang lebar, kita membahas persamaan Steinhart-Hart dan pemanasan diri NTC di panduan termistor NTC.

Ide proyek pembagi tegangan

• Pemantau baterai dan alarm baterai lemah: pantau aki di mobil camper atau instalasi tenaga surya, dan bunyikan buzzer ketika tegangannya turun di bawah 11,8 V; untuk pilihan pemberian daya di proyek baterai, lihat Cara Memberi Daya ke Arduino.
• Voltmeter digital: tampilkan tegangan yang kamu ukur di layar LCD atau OLED; langkah-langkahnya ada di Membuat Voltmeter Arduino.
• Lampu tidur otomatis: pakai pembagi LDR untuk menyalakan LED atau relay ketika hari mulai gelap.
• Pelacak matahari: bandingkan tegangan dua pembagi LDR untuk memutar panel ke arah cahaya (pelacak matahari).
• Lima tombol di satu pin: buat tangga dari resistor yang berbeda-beda, lalu tentukan tombol mana yang ditekan dari nilai analognya (menghubungkan tombol).
• Termostat: ukur suhu dengan pembagi NTC, lalu nyalakan kipas atau pemanas lewat relay pada suhu yang kamu atur.

Kesalahan umum dan cara mengatasinya

Pembagi tegangan hanyalah dua resistor dan satu rumus, tetapi ia muncul di hampir setiap proyek yang mengukur sesuatu. Pilih rasionya dengan rumus, pilih nilai mutlaknya dengan menyeimbangkan arus dan hambatan output, perhitungkan efek pembebanan, dan kalibrasi hasilnya dengan multimeter, maka kamu akan mendapat pembacaan yang andal. Latar belakang tentang pembacaan analog bisa kamu baca di Apa Itu ADC?. Di aplikasi BlueGrays kamu akan menemukan proyek seperti mengukur intensitas cahaya dengan LDR, lampu tidur dengan LDR, voltmeter digital dengan layar LCD, mengukur suhu dengan NTC, dan pengukur jarak HC-SR04 dengan ESP32, masing-masing dijelaskan langkah demi langkah dengan skema rangkaian dan kode.