Gerilim Bölücü Nedir? Formül, Direnç Seçimi ve Arduino ile Ölçüm

Gerilim bölücü, seri bağlı iki dirençle bir gerilimi daha küçük ve hesaplanabilir bir gerilime indiren en basit devredir. Çıkış gerilimi Vout = Vin × R2 / (R1 + R2) formülüyle bulunur: R1 kaynağa, R2 toprağa (GND) bağlıdır ve çıkış ikisinin birleştiği orta noktadan alınır. Örneğin 10 kΩ'luk iki direnç 12 V'u tam yarıya, 6 V'a böler. Arduino ile 12 V'luk bir aküyü ölçmekten 5 V'luk bir sensör sinyalini ESP32'nin 3,3 V'luk pinine uygun hale getirmeye, LDR ve NTC gibi sensörleri okumaya kadar sayısız devrenin temelinde bu iki direnç vardır.

Bu yazıda formülün nereden geldiğini, direnç değerlerini nasıl seçeceğini ve bölücüye bir şey bağladığında çıkışın neden düştüğünü (yük etkisi) gerçek sayılarla göreceksin. Ardından Arduino Uno, ESP32 ve Raspberry Pi Pico ile pil ve akü gerilimi ölçen kodları adım adım kuracak, 5 V'u 3,3 V'a indirmek için doğru direnç çiftlerini seçecek ve LDR ile NTC'yi bölücüyle okuyacağız. Son olarak gerilim bölücünün neden asla bir güç kaynağı yerine kullanılmaması gerektiğini açıklayacağız.

Gerilim bölücü nedir, nasıl çalışır?

Gerilim bölücünün formülü doğrudan Ohm kanunundan çıkar. Kaynakla toprak arasına seri bağlanan R1 ve R2'den aynı akım geçer: I = Vin / (R1 + R2). R2'nin üzerindeki gerilim, yani çıkış, bu akımla R2'nin çarpımıdır: Vout = I × R2 = Vin × R2 / (R1 + R2). Kısacası kaynak gerilimi dirençler arasında değerleriyle orantılı olarak paylaşılır; büyük direncin üzerine büyük pay düşer. Çıkış her zaman girişten küçüktür, çünkü R2 / (R1 + R2) oranı 1'den küçüktür. Seri devrelerde gerilimin nasıl paylaşıldığını seri ve paralel direnç hesaplama yazısında daha ayrıntılı bulabilirsin.

Ters yönden de düşünebilirsin: 12 V'u 3,3 V'a indirmek istiyorsan ve R2 olarak 10 kΩ seçtiysen R1 = 10 × (12 / 3,3 − 1) ≈ 26,4 kΩ çıkar. Bu değer piyasada olmadığı için bir üstteki standart değer olan 27 kΩ'u seçersin; çıkış 12 × 10 / 37 ≈ 3,24 V olur. R1'i yukarı yuvarlamak çıkışı biraz düşürür, bu da pin için güvenli taraftır. Bir potansiyometre de aslında ayarlanabilir bir gerilim bölücüdür: orta ucu, direnç yolunu R1 ve R2 olarak ikiye ayırır. Hesabı elle yapmak istemezsen gerilim bölücü hesaplayıcısı giriş gerilimine ve dirençlere göre çıkışı anında verir. Elektronikte gerilim bölücüyü en çok şu işlerde görürsün:

• Yüksek gerilim ölçmek: 12 V'luk bir akü ya da 7,4 V'luk bir lityum paket gibi kaynakları analog girişin ölçebileceği aralığa indirmek.
• Seviye düşürmek: 5 V'luk bir sinyali ESP32 ve Raspberry Pi Pico'nun 3,3 V'luk girişlerine uygun hale getirmek.
• Direnci değişen sensörleri okumak: LDR, NTC, esneme (flex) sensörü ve kuvvet sensörü (FSR) gibi elemanların direnç değişimini gerilime çevirmek.
• Tek pinden birçok buton okumak: Farklı dirençlerle kurulan bir direnç merdiveni her butona farklı bir gerilim verir ve beş butonu tek bir analog pinde toplar.
• Regülatör geri beslemesi: LM317 ve ayarlı LM2596 gibi regülatörler çıkış gerilimini bir bölücüyle ölçerek sabit tutar; LM317'de Vout = 1,25 × (1 + R2 / R1) olur.
• Referans gerilimi üretmek: Op-amp devrelerinde besleme geriliminin yarısını referans olarak üretmek.

Direnç değerleri nasıl seçilir?

Formül yalnızca oranla ilgilenir: 1 kΩ + 1 kΩ ile 100 kΩ + 100 kΩ aynı oranda, yani tam yarı yarıya böler. Ama pratikte mutlak değerler de önemlidir. Küçük dirençler bölücüden fazla akım geçirir; bu akım boşa harcanan enerjidir ve pilli projelerde pili gereksiz yere tüketir. Büyük dirençler ise çok az akım çeker, fakat çıkışları zayıf olur: bağlanan bir yük ya da analog girişin içindeki örnekleme kondansatörü çıkış gerilimini kolayca bozar, kablolardan gelen gürültü de daha kolay işler. Doğru seçim bu iki uç arasında bir dengedir:

1. En yüksek giriş gerilimini belirle. 12 V'luk bir kurşun asit akü şarj olurken 14,4 V'a çıkabilir; ölçeceğin gerilimin en kötü durumunu al ve üstüne %10 pay ekle.
2. Pinin kabul ettiği en yüksek gerilimi belirle. Arduino Uno'da 5 V, ESP32 ve Pico'da 3,3 V; güvenli hedef olarak Uno'da yaklaşık 4,5 V, ESP32'de 2,5 V, Pico'da 3,0 V seç.
3. Oranı hesapla: k = hedef çıkış / en yüksek giriş. Örneğin 4,5 / 14,4 ≈ 0,31.
4. R2'yi seç (çoğu durumda 10 kΩ iyi bir başlangıçtır) ve R1'i R1 = R2 × (1 / k − 1) ile bul. Sonucu standart direnç değerleri arasından bir üst değere yuvarla.
5. Akımı ve gücü kontrol et: I = Vin / (R1 + R2) ve P = Vin² / (R1 + R2). Pilli projelerde akımı mikroamper düzeyinde tutmaya çalış.
6. Çıkış direncini kontrol et: R1 × R2 / (R1 + R2), Arduino Uno için 10 kΩ'un altında olmalı; değilse analog pin ile GND arasına 100 nF kondansatör ekle.
7. Gerçek oranı koda yaz: Seçtiğin standart değerlerle oranı yeniden hesapla, devreyi kurduktan sonra multimetreyle ölçüp kalibre et.

Yük etkisi: Bölücüye bir şey bağlarsan ne olur?

Formül, çıkıştan hiç akım çekilmediğini varsayar. Çıkışa bir yük bağladığın anda bu yük R2'ye paralel hale gelir, alt koldaki eşdeğer direnç küçülür ve çıkış gerilimi düşer. Bunu hesaplamanın kolay yolu bölücüyü Thevenin eşdeğeri olarak düşünmektir: bölücü, yük yokken ölçtüğün gerilime (Vth) ve Rth = R1 × R2 / (R1 + R2) iç direncine sahip bir kaynak gibi davranır. RL yükü bağlandığında çıkış Vth × RL / (Rth + RL) olur. Aşağıdaki tabloda 10 V'luk bir kaynağı 10 kΩ + 10 kΩ ile böldüğümüzü (Vth = 5 V, Rth = 5 kΩ) ve çıkışa farklı yükler bağladığımızı görüyorsun:

Pratik kural şu: yükün direnci bölücünün çıkış direncinin (Rth) en az 100 katı olursa hata %1'in altında kalır. Yük daha küçükse ya dirençleri küçültürsün ya da araya bir op-amp gerilim izleyici (tampon) koyarsın. Mikrodenetleyicinin analog girişi kendisi çok yüksek dirençlidir, ama içinde her ölçümde şarj edilen küçük bir örnekleme kondansatörü vardır (ATmega328P'de yaklaşık 14 pF). Veri sayfası bu yüzden kaynağın çıkış direncinin yaklaşık 10 kΩ ya da daha düşük olmasını önerir. Daha büyük dirençli bir bölücü kullanıyorsan analog pin ile GND arasına 100 nF'lık bir kondansatör ekle: kondansatör, örnekleme anında gereken yükü hazır tutar. Birden fazla analog pini sırayla okuyorsan her pinde ilk okumayı atmak da kanal değişiminden kalan hatayı temizler.

Gerilim bölücü neden güç kaynağı olarak kullanılmaz?

Yeni başlayanların en sık düştüğü tuzak, 12 V'luk bir adaptörden iki dirençle 5 V elde edip Arduino'yu ya da bir modülü bununla beslemeye çalışmaktır. Kâğıt üzerinde 7 kΩ ve 5 kΩ'luk bir bölücü 12 V'tan tam 5 V verir, ama yalnızca çıkıştan akım çekilmezken. 50 mA çeken bir kart yaklaşık 100 Ω'luk bir yük gibi davranır; 5 kΩ'luk R2'ye paralel bağlandığında alt kol 98 Ω'a iner ve çıkış 0,17 V'a çöker. Dirençleri 70 Ω ve 50 Ω'a küçültürsen bu kez devre hiçbir şey bağlı değilken bile 100 mA çeker ve 1,2 W ısı üretir; yük bağlandığında çıkış yine 3,9 V'a düşer ve kartın çektiği akım her değiştiğinde (Wi-Fi, servo, röle) gerilim de oynar. Üstelik yük çıkarıldığında gerilim yeniden yükselir ve hassas parçalar zarar görebilir.

Arduino ile 12 V akü ve pil gerilimi ölçme

Arduino Uno'nun analog girişleri en fazla 5 V okuyabilir; 12 V'luk bir aküyü doğrudan bağlamak pini yakar. Çözüm 22 kΩ (R1) ve 10 kΩ'luk (R2) bir bölücüdür: oran 0,3125 olduğundan 14,4 V'luk şarj gerilimi pine 4,5 V olarak ulaşır ve devre en fazla 16 V'a kadar ölçebilir. Bölücü 12 V'ta yalnızca 0,375 mA çeker, 6,9 kΩ'luk çıkış direnci de önerilen 10 kΩ sınırının altındadır. 10 bitlik ADC her adımda yaklaşık 4,9 mV ayırt eder; bölücüyle bu, girişte yaklaşık 15,6 mV'luk bir çözünürlüğe karşılık gelir. ESP32 ve Pico 3,3 V ile çalıştığı için onlarda daha büyük bir R1 (56 kΩ) kullanıyoruz:

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}

Kod, ADC'nin örnekleme kondansatörü otursun diye ilk okumayı atar, ardından 16 ölçümün ortalamasını alarak gürültüyü azaltır. Okunan sayı önce pindeki gerilime çevrilir (ATmega328P'nin veri sayfasına göre ADC = Vin × 1024 / Vref olduğu için 1024'e bölüyoruz), sonra (R1 + R2) / R2 = 3,2 ile çarpılarak bölücüden önceki gerilim bulunur. En büyük hata kaynağı Vref'tir: USB'den beslenen bir Uno'nun 5V pini çoğu zaman 4,7–5,1 V arasındadır. Bu yüzden 5V pinini multimetreyle ölçüp VREF'e yaz; ardından akünün gerçek gerilimini multimetreyle ölç, Serial Monitor'deki değerle karşılaştır ve CAL = gerçek / okunan katsayısını koda gir. Bu tek adım Vref ve direnç toleransı hatalarını birlikte düzeltir. Bölücüyü cihazın açma/kapama anahtarından sonra bağlarsan cihaz kapalıyken akım çekmez; 0,375 mA günde yaklaşık 9 mAh eder, bu bir otomobil aküsü için önemsizdir ama küçük bir pilde hissedilir. Farklı kaynaklar için uygun direnç çiftleri şöyle:

ESP32 ile gerilim ölçme

ESP32'de ADC 12 bittir (0–4095), ama iki önemli farkı vardır. Birincisi, Wi-Fi açıkken ADC2 pinleri okunamaz; bölücüyü mutlaka ADC1'e ait GPIO 32–39'dan birine bağla (GPIO 34–39 yalnızca giriş olarak çalışır ve bu iş için idealdir). İkincisi, ADC uçlarda doğrusal değildir: Espressif, varsayılan 11 dB zayıflatmada en doğru ölçüm aralığı olarak yaklaşık 150–2450 mV'u önerir. Pin 3,1 V civarına kadar bir değer gösterse de bu bölgede hata büyür. Bu yüzden 56 kΩ + 10 kΩ'luk bölücüyü seçtik: 14,4 V pine 2,18 V olarak ulaşır ve doğru bölgede kalır. Ham analogRead() yerine, yongaya üretimde yazılan kalibrasyon verisini kullanarak doğrudan milivolt döndüren analogReadMilliVolts() fonksiyonunu kullanıyoruz:

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}

Raspberry Pi Pico ile gerilim ölçme (MicroPython)

Raspberry Pi Pico'da analog girişler GP26, GP27 ve GP28'dir (ADC0–ADC2). MicroPython'daki read_u16() fonksiyonu 12 bitlik ölçümü 0–65535 aralığına ölçekler; referans ise kartın 3,3 V'undan gelen ADC_VREF'tir. Pico'nun ADC'si 3,3 V'a kadar ölçebildiği için 56 kΩ + 10 kΩ ile yaklaşık 21 V'a kadar çıkabilirsin. İlginç bir ayrıntı: Pico'nun kendisi de bir gerilim bölücü kullanır. Kart üzerindeki bölücü VSYS besleme gerilimini üçe böler ve GP29'a (ADC3) bağlar; ADC(29) ile okuduğun gerilimi 3 ile çarparak kartın besleme gerilimini görebilirsin (Pico W'de GP29 kablosuz yongayla paylaşıldığı için bu yöntem doğrudan çalışmaz).

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)

5 V sinyali 3,3 V'a indirme (ESP32 ve Pico için)

ESP32 ve Pico'nun pinleri 5 V'a dayanıklı değildir. HC-SR04'ün ECHO çıkışı, bir Arduino Uno'nun TX pini ya da 5 V ile beslenen bir modülün dijital çıkışı bu kartlara doğrudan bağlanırsa girişteki koruma diyotları zorlanır ve pin zamanla bozulabilir. Tek yönlü sinyallerde en ucuz çözüm bir gerilim bölücüdür. Hedef, 3,3 V'u aşmayan ama kartın HIGH olarak algılayacağı kadar yüksek bir gerilimdir: ESP32, besleme geriliminin %75'ini (yaklaşık 2,5 V), Pico'daki RP2040 ise 2,0 V'u HIGH için alt sınır kabul eder. Bu yüzden 3,0–3,3 V arası bir çıkış iki kart için de rahat bir paydır. HC-SR04 mesafe sensörü yazısında ECHO pinini 3,3 V'luk kartlara bağlarken önerilen yöntem de budur.

Bölücü, pinin kendi kapasitansıyla birlikte küçük bir RC filtre oluşturur. 10 kΩ + 20 kΩ'luk bölücünün 6,7 kΩ'luk çıkış direnci, pin ve breadboard'un yaklaşık 15 pF'lık kapasitansıyla 100 ns civarında bir zaman sabiti verir; 115200 baud'luk bir UART (bit süresi 8,7 µs) bundan etkilenmez, ama birkaç MHz'lik SPI sinyallerinin kenarları yuvarlanır. Hızlı hatlarda 1 kΩ + 2 kΩ'u tercih et. Bölücünün yalnızca tek yönde, yüksek gerilimden alçak gerilime doğru çalıştığını da unutma. Ters yönde çoğu zaman bir şey yapman gerekmez: Arduino Uno 3,0 V'un üstünü HIGH sayar, bu yüzden ESP32'nin 3,3 V'luk çıkışını küçük bir payla da olsa okuyabilir. I2C gibi iki yönlü hatlarda ise bölücü işe yaramaz; orada MOSFET'li bir lojik seviye dönüştürücü kullanılır.

LDR ve NTC'yi gerilim bölücüyle okumak

Mikrodenetleyiciler direnci doğrudan ölçemez, yalnızca gerilim ölçer. LDR ve NTC gibi direnci değişen sensörleri bir sabit dirençle seri bağlayıp gerilim bölücü kurduğunda, direnç değişimi orta noktada gerilim değişimine dönüşür. Sabit direncin değeri ölçümün hassasiyetini belirler. En büyük gerilim farkını almak için sabit direnç, sensörün ölçmek istediğin aralıktaki en küçük ve en büyük dirençlerinin geometrik ortalaması olmalıdır: R = √(Rmin × Rmax). Örneğin aydınlıkta 1 kΩ, loş ortamda 100 kΩ olan bir LDR için √(1 k × 100 k) = 10 kΩ çıkar. 5 V'ta 10 kΩ ile çıkış 4,09 V'luk bir aralıkta değişirken 1 kΩ ya da 100 kΩ ile bu aralık 2,45 V'a iner. Başlangıç setlerindeki 10 kΩ'un sebebi budur. Bir avantaj daha var: hem bölücü hem ADC aynı 5 V'tan beslendiği için hesaplanan direnç besleme geriliminden bağımsızdır (oransal ölçüm); bu yüzden aşağıdaki kodda Vref değerine bile gerek yoktur.

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}

Kodda LDR üstte olduğu için ışık arttıkça okunan değer de artar; LDR'nin direnci R = 10 kΩ × (1024 / ADC − 1) ile bulunur. NTC ise altta durur ve sıcaklık arttıkça direnci, dolayısıyla okunan gerilim düşer. 25 °C'de 10 kΩ olan ve B katsayısı 3950 olan yaygın NTC'ler için sıcaklık Beta denklemiyle hesaplanır: 1 / T = 1 / T0 + ln(R / R0) / B (sıcaklıklar kelvin cinsinden). Sabit direnç NTC'nin 25 °C'deki direnciyle aynı seçildiği için oda sıcaklığında çıkış besleme geriliminin tam yarısıdır ve hassasiyet en yüksek bu bölgededir. Geniş bir sıcaklık aralığında daha yüksek doğruluk için Steinhart-Hart denklemini ve NTC'nin kendi kendini ısıtmasını NTC termistör yazısında ele alıyoruz.

Gerilim bölücü ile proje fikirleri

• Akü izleme ve düşük pil alarmı: Karavan ya da güneş enerjisi sistemindeki aküyü izle, gerilim 11,8 V'un altına inince buzzer çalsın; pilli projelerde besleme seçenekleri için Arduino'yu pille çalıştırma yazısına bak.
• Dijital voltmetre: Ölçtüğün gerilimi LCD ya da OLED ekranda göster; adımlar Arduino voltmetre yapımı yazısında.
• Otomatik gece lambası: LDR'li bir bölücüyle ortam kararınca LED'leri ya da bir röleyi devreye al.
• Güneş takip sistemi: İki LDR bölücüsünün gerilimlerini karşılaştırarak paneli ışığa çevir (güneş takip sistemi).
• Tek pinde beş buton: Farklı dirençlerden bir merdiven kur, hangi butona basıldığını analog değerden anla (buton bağlantısı).
• Termostat: NTC bölücüsüyle sıcaklığı ölç, belirlediğin sıcaklıkta fanı ya da ısıtıcıyı bir röleyle aç.

Sık yapılan hatalar ve çözümleri

Gerilim bölücü yalnızca iki direnç ve tek bir formülden ibarettir, ama ölçüm yapan hemen her projenin bir yerinde karşına çıkar. Oranı formülle, mutlak değerleri akım ile çıkış direnci arasındaki dengeyle seçer, yük etkisini hesaba katar ve sonucu multimetreyle kalibre edersen güvenilir ölçümler alırsın. Analog okumanın arka planını ADC nedir? yazısında okuyabilirsin. BlueGrays uygulamasında LDR ile ışık şiddeti okuma, LDR'li gece lambası, LCD ekranlı dijital voltmetre, NTC ile sıcaklık ölçümü ve ESP32 ile HC-SR04 mesafe ölçer gibi projeleri devre şemaları ve kodlarıyla adım adım bulabilirsin.