Arduino map() Fonksiyonu: Kullanımı, Örnekler ve constrain
Arduino map() fonksiyonu nasıl kullanılır? Sözdizimi, tamsayı bölme tuzağı, constrain ile sınırlama, potansiyometreden servo ve PWM'e örnekler, ESP32 ve Pico.
Arduino map() fonksiyonu, bir sayı aralığındaki değeri orantılı olarak başka bir aralığa çeviren yerleşik bir komuttur. Potansiyometreden okuduğun 0–1023 arasındaki değeri servo için 0–180 dereceye, LED parlaklığı için 0–255 PWM değerine ya da ekranda göstermek için yüzde 0–100'e dönüştürmek istediğinde tek satırla işini görür. Kısacası map(), elindeki ölçeği hedeflediğin ölçeğe uyduran bir cetvel çeviricidir.
Ancak map() göründüğü kadar masum değildir: yalnızca tamsayılarla çalışır, ondalık kısmı atar ve sonucu hedef aralıkla sınırlamaz. Bu yazıda fonksiyonun formülünü, tamsayı bölmesinin neden olduğu sürprizleri, constrain() ile güvenli kullanımı, potansiyometreden servoya ve sensörden PWM'e gerçek örnekleri, ayrıca ESP32'nin 12 bitlik ADC'sinde ve Raspberry Pi Pico'da MicroPython ile aynı işin nasıl yapıldığını adım adım göreceksin.

Arduino map() nedir, nasıl çalışır?
map() iki aralık arasında doğrusal bir orantı kurar. Girişteki değerin kendi aralığında yüzde kaçlık bir konumda olduğunu bulur, sonra hedef aralıkta aynı konuma karşılık gelen sayıyı hesaplar. Arduino çekirdeğindeki tanımı tek satırdır: (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min. Tüm parametreler ve dönüş değeri long türündedir; yani Uno'da 32 bitlik işaretli tamsayıdır. Söz dizimi map(değer, girişMin, girişMax, çıkışMin, çıkışMax) şeklindedir ve kullanmak için herhangi bir kütüphane eklemen gerekmez.
| Parametre | Anlamı | Pot → servo örneği |
|---|---|---|
| value (x) | Dönüştürülecek değer | analogRead(A0) sonucu |
| fromLow (in_min) | Giriş aralığının alt sınırı | 0 |
| fromHigh (in_max) | Giriş aralığının üst sınırı | 1023 |
| toLow (out_min) | Çıkış aralığının alt sınırı | 0 |
| toHigh (out_max) | Çıkış aralığının üst sınırı | 180 |
| Dönüş değeri | Hedef aralıktaki karşılık (long) | 0–180 arası açı |
Bir örnekle hesaplayalım: potansiyometre tam ortadayken analogRead() yaklaşık 512 döndürür. map(512, 0, 1023, 0, 180) için önce 512 - 0 = 512 bulunur, bu değer 180 - 0 = 180 ile çarpılır ve 92160 elde edilir. Sonra 1023'e bölünür: 92160 / 1023 = 90,09. Tamsayı bölmesi ondalığı attığı için sonuç 90 derecedir; son olarak çıkış alt sınırı olan 0 eklenir. Çıkış sınırlarını ters yazarsan yön de tersine döner: map(x, 0, 1023, 255, 0) potansiyometre arttıkça azalan bir değer üretir. Negatif aralıklar da sorunsuz çalışır; bir joystick eksenini map(x, 0, 1023, -255, 255) ile ileri-geri motor hızına çevirebilirsin. Aşağıdaki tablo en sık kullanılan dönüşümleri özetliyor.
| Amaç | Kod | Not |
|---|---|---|
| Potansiyometre → servo açısı | map(x, 0, 1023, 0, 180) | Servo.write() için |
| Potansiyometre → PWM | map(x, 0, 1023, 0, 255) | analogWrite() için; x / 4 daha eşit dağılım verir |
| Analog okuma → yüzde | map(x, 0, 1023, 0, 100) | Ekranda yüzde göstermek için |
| Joystick → motor hızı ve yön | map(x, 0, 1023, -255, 255) | İşaret yönü, büyüklük hızı verir |
| Ters yön (karanlık → parlak) | map(x, 0, 1023, 255, 0) | Çıkış sınırlarını yer değiştir |
| ESP32 12 bit ADC → PWM | map(x, 0, 4095, 0, 255) | ESP32'de analogRead() 0–4095 döndürür |
Tamsayı bölme kısıtı: map() neden ondalık vermez?
map() içindeki bölme işlemi tamsayılarla yapıldığı için sonuç her zaman sıfıra doğru kesilir; ondalık kısım yuvarlanmaz, düpedüz atılır. Dar bir hedef aralıkta bu çok belirgin hâle gelir. Örneğin potansiyometreyi 0–10 arası bir seviye göstergesine çevirmek için map(x, 0, 1023, 0, 10) yazarsan şu tablo ortaya çıkar:
| Giriş (x) | Gerçek oran | map() sonucu |
|---|---|---|
| 0 | 0,000 | 0 |
| 102 | 0,997 | 0 |
| 103 | 1,007 | 1 |
| 512 | 5,005 | 5 |
| 1022 | 9,990 | 9 |
| 1023 | 10,000 | 10 |
Tablodaki asıl sorun şudur: 0 sonucunu 103 farklı giriş değeri (0–102) üretirken en üst değer olan 10'u yalnızca tek bir giriş, yani 1023 verir. Potansiyometreyi sonuna kadar çevirmezsen göstergen hiçbir zaman 10'a ulaşmaz. Eşit dağılım istiyorsan iki üst sınırı da bir artırıp map(x, 0, 1024, 0, 11) yazabilirsin; böylece her çıkış değeri yaklaşık 93 giriş değerine denk gelir ve sonuç yine 0–10 arasında kalır. İkinci kısıt taşmadır: ara çarpım olan (x - in_min) * (out_max - out_min), 32 bitlik long sınırını, yani yaklaşık 2,1 milyarı aşarsa sonuç bozulur. map(50000, 0, 100000, 0, 100000) gibi büyük aralıklar Uno'da 5 milyarlık bir ara çarpım üretir ve yanlış sonuç verir. Üçüncü kısıt ondalık ihtiyacıdır: analog okumayı 0–5 V gerilime çevirmek için map(x, 0, 1023, 0, 5) yazarsan yalnızca 0, 1, 2, 3, 4 ve 5 sonuçlarını alırsın. Bu durumda aynı formülle kendi ondalıklı map fonksiyonunu yazmalısın:
1// Ondalikli map fonksiyonu / Floating-point map function
2float mapFloat(float x, float inMin, float inMax, float outMin, float outMax) {
3 return (x - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
4}
5
6void setup() {
7 Serial.begin(9600);
8}
9
10void loop() {
11 int raw = analogRead(A0); // 0-1023 ham deger / raw value
12 float volt = mapFloat(raw, 0, 1023, 0.0, 5.0); // 0.00-5.00 V
13 long milliVolt = map(raw, 0, 1023, 0, 5000); // tamsayi mV / integer mV
14 int percent = map(raw, 0, 1023, 0, 100); // tamsayi yuzde / integer percent
15
16 Serial.print(F("Ham / Raw: "));
17 Serial.print(raw);
18 Serial.print(F(" V: "));
19 Serial.print(volt, 2);
20 Serial.print(F(" mV: "));
21 Serial.print(milliVolt);
22 Serial.print(F(" %: "));
23 Serial.println(percent);
24 delay(500);
25}constrain ile birlikte kullanım
map() hedef aralığı bir sınır olarak görmez; yalnızca bir orantı hesaplar. Giriş değeri beklediğin aralığın dışına çıkarsa çıkış da dışarı taşar. Diyelim ki bir LDR'nin gerçekte 200 ile 900 arasında değer verdiğini ölçtün ve map(x, 200, 900, 0, 255) yazdın. Güçlü bir el feneri değeri 980'e çıkardığında sonuç (980 - 200) * 255 / 700 = 284 olur; ortam çok karanlıkken değer 150'ye düşerse -18 elde edersin. Uno'da analogWrite() 255'ten büyük değeri pine göre farklı yorumlar; örneğin 6. pinde 284, 8 bite kesilip 28'e, yani neredeyse sönük bir LED'e dönüşür. Çözüm constrain(değer, alt, üst) fonksiyonudur: değeri verilen sınırlar içine sıkıştırır. İki doğru sıralama vardır: girişi map()'ten önce sınırlamak, yani map(constrain(x, 200, 900), 200, 900, 0, 255) ya da sonucu map()'ten sonra sınırlamak, yani constrain(map(x, 200, 900, 0, 255), 0, 255). İkisi de 0–255 dışına çıkmayı engeller; sensör kalibrasyonu yapıyorsan girişi sınırlamak daha okunaklıdır.
Bağlantı tablosu: Arduino Uno, ESP32 ve Pico
| Bağlantı | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Potansiyometre dış uçları | 5V ve GND | 3V3 ve GND | 3V3 ve GND |
| Potansiyometre orta ucu | A0 | GPIO 34 | GP26 (ADC0) |
| LDR + 10 kΩ bölücü orta noktası | A1 | GPIO 35 | GP27 (ADC1) |
| LED (220 Ω dirençle) | D6 (PWM) | GPIO 25 | GP15 |
| Servo sinyal (turuncu kablo) | D9 | GPIO 13 | GP16 |
| ADC okuma aralığı | 10 bit (0–1023) | 12 bit (0–4095) | read_u16(): 0–65535 |
Adım adım: potansiyometre ile servo açısı ayarlamak
- 10 kΩ potansiyometrenin iki dış ucunu Arduino'nun 5V ve GND pinlerine, orta ucunu A0'a bağla.
- SG90 servonun kahverengi kablosunu GND'ye, kırmızısını 5V'a, turuncu sinyal kablosunu D9'a bağla.
- Servo kütüphanesinin kurulu olduğunu kontrol et; Arduino IDE ile birlikte gelir, ayrıca bir şey indirmen gerekmez.
- Aşağıdaki kodu yükle ve Seri Monitör'ü 9600 baud hızında aç.
- Potansiyometreyi çevirirken ekranda ham değerle açının birlikte değiştiğini ve servonun 0–180 derece arasında döndüğünü gözlemle.
- Servo uç noktalarda zorlanıp vızıldıyorsa map() çıkışını 10–170 gibi daha dar bir aralığa çek.
1#include <Servo.h>
2
3const int POT_PIN = A0; // potansiyometre orta ucu / potentiometer wiper
4const int SERVO_PIN = 9; // servo sinyal pini / servo signal pin
5
6Servo servo;
7
8void setup() {
9 servo.attach(SERVO_PIN);
10 Serial.begin(9600);
11}
12
13void loop() {
14 int raw = analogRead(POT_PIN); // 0-1023 ham deger / raw value
15 int angle = map(raw, 0, 1023, 0, 180); // dereceye cevir / convert to degrees
16 angle = constrain(angle, 0, 180); // guvenlik siniri / safety limit
17 servo.write(angle);
18
19 Serial.print(F("Ham / Raw: "));
20 Serial.print(raw);
21 Serial.print(F(" Aci / Angle: "));
22 Serial.println(angle);
23 delay(20); // servoya zaman tani / give the servo time
24}Kodda analogRead() 10 bitlik bir değer döndürür, map() bunu dereceye çevirir, constrain() ise ileride aralığı değiştirdiğinde bile servoya 0–180 dışında bir açı gitmemesini garanti eder. Uno'nun ADC'si hafif gürültülü olduğu için potansiyometreye dokunmasan da değer 511, 512 ve 513 arasında oynayabilir; bu da servonun titremesine yol açar. Birkaç okumanın ortalamasını almak ya da açı yalnızca 2 dereceden fazla değiştiğinde servo.write() çağırmak sorunu büyük ölçüde çözer. Ayrıntılar için servo titreme sorunu ve sensör verisi filtreleme yazılarına bakabilirsin. Servonun çalışma mantığını merak ediyorsan Servo Motor Nedir? yazısı iyi bir başlangıçtır.
Sensörden PWM'e: LDR ile otomatik LED parlaklığı
map() yalnızca potansiyometrelerle değil, her analog sensörle işe yarar. Bu örnekte LDR'nin bir ucu 5V'a, diğer ucu A1'e bağlı; A1 ile GND arasına da 10 kΩ direnç takılı. Bu bağlantıda ışık arttıkça LDR'nin direnci düşer ve A1'deki gerilim yükselir. Önce Seri Monitör'den karanlık odada ve aydınlıkta okunan değerleri not et; örneğin 150 ve 850. Bu iki sayı kalibrasyon sınırlarındır. Kod ortam karardıkça LED'i parlatır, bu yüzden çıkış aralığı ters yazılır: 255'ten 0'a. LDR'nin çalışma prensibi için LDR Işık Sensörü, PWM'in arka planı için PWM Nedir? yazılarına göz at.
1const int LDR_PIN = A1; // LDR + 10k bolucu / LDR + 10k divider
2const int LED_PIN = 6; // PWM pini / PWM pin
3const int DARK = 150; // karanlikta olculen / measured in the dark
4const int BRIGHT = 850; // aydinlikta olculen / measured in bright light
5
6void setup() {
7 pinMode(LED_PIN, OUTPUT);
8 Serial.begin(9600);
9}
10
11void loop() {
12 int raw = analogRead(LDR_PIN);
13 int limited = constrain(raw, DARK, BRIGHT); // once sinirla / limit first
14 int pwm = map(limited, DARK, BRIGHT, 255, 0); // karanlik = parlak / dark = bright
15 analogWrite(LED_PIN, pwm);
16
17 Serial.print(raw);
18 Serial.print(F(" -> "));
19 Serial.println(pwm);
20 delay(100);
21}ESP32'de map(): 12 bit ADC ve LEDC PWM
ESP32'de map() aynı biçimde çalışır, değişen şey giriş aralığıdır. ESP32'nin ADC'si varsayılan olarak 12 bit çözünürlüklüdür, yani analogRead() 0–1023 yerine 0–4095 döndürür. Uno'dan taşıdığın kodda map(x, 0, 1023, ...) bırakırsan potansiyometrenin yalnızca ilk çeyreğinde tüm çıkış aralığını tüketirsin, geri kalan kısımda ise değerler hedef aralığın dört katına kadar taşar. Bu yüzden ESP32'de girişi 0–4095 olarak yaz ya da analogReadResolution(10) ile 10 bite düş. PWM tarafında ESP32 LEDC birimini kullanır; Arduino çekirdeği 3.x ile ledcAttach(pin, frekans, çözünürlük) geldi, 2.x'te ise kanal tabanlı ledcSetup() ve ledcAttachPin() kullanılır. Aşağıdaki kod iki sürümde de derlenir. Wi-Fi açıkken ADC2 pinleri okunamadığı için potansiyometreyi ADC1'e bağlı GPIO 34'e takıyoruz. ESP32'de servo sürmek istersen ESP32Servo kütüphanesiyle aynı mantıkta map(x, 0, 4095, 0, 180) satırını kullanabilirsin.
1const int POT_PIN = 34; // ADC1 pini, yalniz giris / ADC1 pin, input only
2const int LED_PIN = 25; // PWM cikisi / PWM output
3const int PWM_FREQ = 5000; // 5 kHz
4const int PWM_RES = 8; // 8 bit: 0-255
5
6#if ESP_ARDUINO_VERSION_MAJOR < 3
7const int PWM_CH = 0; // 2.x icin LEDC kanali / LEDC channel for 2.x
8#endif
9
10void setup() {
11 Serial.begin(115200);
12 analogReadResolution(12); // 0-4095
13#if ESP_ARDUINO_VERSION_MAJOR >= 3
14 ledcAttach(LED_PIN, PWM_FREQ, PWM_RES);
15#else
16 ledcSetup(PWM_CH, PWM_FREQ, PWM_RES);
17 ledcAttachPin(LED_PIN, PWM_CH);
18#endif
19}
20
21void loop() {
22 int raw = analogRead(POT_PIN); // 0-4095
23 int duty = map(raw, 0, 4095, 0, 255); // 12 bit -> 8 bit
24 duty = constrain(duty, 0, 255);
25#if ESP_ARDUINO_VERSION_MAJOR >= 3
26 ledcWrite(LED_PIN, duty); // 3.x: pin numarasi / pin number
27#else
28 ledcWrite(PWM_CH, duty); // 2.x: kanal numarasi / channel number
29#endif
30 Serial.printf("%d -> %d\n", raw, duty);
31 delay(20);
32}ESP32 ADC'sinin bilmen gereken bir huyu var: uç noktalarda doğrusal değildir. Varsayılan zayıflatma ayarında yaklaşık 0,1 V'un altındaki gerilimler 0 olarak okunur, 3,1 V civarından sonra da değer 4095'e doyar; arada ölçüm hafifçe eğridir. Bu yüzden potansiyometreyi sonuna kadar çevirmeden 4095'e ulaşabilir ya da başlangıçta ölü bir bölge hissedebilirsin. Pratik çözüm, gerçek en küçük ve en büyük okumaları ölçüp map() ve constrain() içinde bu sınırları kullanmaktır. Gerilim gerekiyorsa map yerine fabrika kalibrasyonunu kullanan analogReadMilliVolts() fonksiyonu daha doğru sonuç verir. Kartın genel özellikleri için ESP32 Nedir? yazısına bakabilirsin.
Raspberry Pi Pico ve MicroPython'da map() karşılığı
MicroPython'da Arduino'daki gibi hazır bir map() yoktur; Python'daki map() tamamen başka bir iş yapar ve bir listeye fonksiyon uygular. Bu yüzden aynı formülü kendin yazarsın. Pico'da ADC.read_u16() fiziksel olarak 12 bitlik ölçümü 16 bite ölçeklenmiş hâlde, 0–65535 aralığında döndürür; PWM.duty_u16() de 0–65535 arasında bir doluluk oranı bekler. Python tamsayıları sınırsız büyüklükte olduğu için Uno'daki taşma sorununu yaşamazsın. Dikkat etmen gereken fark, // operatörünün sonucu her zaman eksi sonsuza doğru yuvarlamasıdır; C++'taki map() ise sıfıra doğru keser, bu yüzden negatif aralıklarda iki dil arasında 1 birimlik fark görebilirsin. Ondalık sonuç istiyorsan // yerine / kullanman yeterli. Kodda potansiyometre GP26'dan okunuyor, GP15'teki LED parlaklığı, GP16'daki servo ise açıyı takip ediyor. LED için girişi 500–65000 arasına sınırlıyoruz, çünkü Pico'nun ADC'si uçlarda tam 0 ve 65535 değerlerine nadiren ulaşır. Servo tarafında 50 Hz PWM'de 0–180 derece, çoğu SG90 için yaklaşık 500–2500 mikrosaniyelik darbeye karşılık gelir. Pico'ya yeniysen Raspberry Pi Pico Nedir? ve MicroPython temelleri yazılarıyla başlayabilirsin.
1from machine import ADC, Pin, PWM
2import time
3
4pot = ADC(26) # GP26 = ADC0
5led = PWM(Pin(15)) # LED GP15
6led.freq(1000)
7servo = PWM(Pin(16)) # servo sinyal GP16 / servo signal GP16
8servo.freq(50) # 50 Hz = 20 ms periyot / period
9
10def map_range(x, in_min, in_max, out_min, out_max):
11 # Arduino map() karsiligi (tamsayi) / Arduino map() equivalent (integer)
12 return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
13
14def constrain(x, low, high):
15 # degeri sinirla / clamp the value
16 return max(low, min(x, high))
17
18while True:
19 raw = pot.read_u16() # 0-65535
20 percent = map_range(raw, 0, 65535, 0, 100) # yuzde / percent
21 duty = map_range(constrain(raw, 500, 65000), 500, 65000, 0, 65535)
22 led.duty_u16(duty) # LED parlakligi / LED brightness
23 angle = map_range(raw, 0, 65535, 0, 180) # derece / degrees
24 pulse_us = map_range(angle, 0, 180, 500, 2500) # darbe suresi / pulse width
25 servo.duty_ns(pulse_us * 1000) # mikrosaniye -> nanosaniye / us -> ns
26 print(raw, percent, angle, pulse_us)
27 time.sleep_ms(50)map() ile proje fikirleri
- Seviye göstergesi: Potansiyometre ya da ses sensörü değerini map(x, 0, 1024, 0, 9) ile 0–8 arasına çevir ve 8 LED'lik bir çubukta göster.
- Joystick kontrollü araba: Joystick eksenini -255 ile 255 arasına çevir ve L298N ile motorların yönünü ve hızını ayarla.
- Dijital voltmetre: Analog okumayı milivolta çevirip LCD'de göster; ayrıntılar Arduino voltmetre yapımı yazısında.
- Bitki nem yüzdesi: Toprak nem sensörünün kuru ve ıslak kalibrasyon değerlerini constrain() ve map() ile 0–100 yüzdeye dönüştür.
- Işıkla çalan çalgı: LDR ya da mesafe değerini map() ile 200–2000 Hz aralığına çevir ve tone() fonksiyonuna frekans olarak ver.
- Hız ayarlı yürüyen LED: Potansiyometreyi map(x, 0, 1023, 50, 500) ile milisaniye cinsinden bekleme süresine çevir.
Sık yapılan hatalar ve çözümleri
| Belirti | Sebep | Çözüm |
|---|---|---|
| Sonuç hedef aralığın dışına çıkıyor | map() sınırlama yapmaz | Girişi ya da çıkışı constrain() ile sınırla |
| Ondalıklı sonuçlar hep tam sayı geliyor | Tamsayı bölmesi ondalığı atar | mapFloat() yaz ya da birimi küçült (V yerine mV) |
| En üst değere hiç ulaşılmıyor | Üst değer yalnızca tek bir girişte oluşur | map(x, 0, 1024, 0, max + 1) ile eşit dağıt |
| Büyük sayılarda saçma sonuç | Ara çarpım 32 bitlik long sınırını aşıyor | Aralıkları küçült ya da float veya int64_t ile hesapla |
| ESP32'de değer çok erken tavan yapıyor | Kod 0–1023 için yazılmış, ADC 0–4095 veriyor | Giriş aralığını 0–4095 yap |
| Yön ters çalışıyor | Çıkış sınırları ya da sensör bağlantısı ters | Çıkış alt ve üst sınırlarını yer değiştir |
| Sonuç sabit ve anlamsız | in_min ile in_max eşit, yani sıfıra bölme | Kalibrasyon sınırlarının farklı olduğunu kontrol et |
map() fonksiyonu, sensör dünyasıyla çıkış dünyası arasındaki çevirmenindir: tamsayı bölmesini aklında tutar, constrain() ile sınırları korur ve kartının ADC çözünürlüğünü doğru yazarsan Uno, ESP32 ve Pico'da aynı mantıkla çalışır. Potansiyometrenin temellerini Potansiyometre Nedir? yazısında tekrar edebilirsin. BlueGrays uygulamasında hız ayarlı yürüyen LED, LDR ile ışık şiddeti okuma, potansiyometreyle servo kontrolü ve ESP32 ile PWM parlaklık ayarı gibi map() kullanan projeleri adım adım devre şeması ve koduyla inceleyebilirsin.
Sıkça sorulan sorular
Arduino map() fonksiyonu ne işe yarar?
map(), bir aralıktaki sayıyı orantılı olarak başka bir aralığa çevirir. En sık kullanımı analogRead() ile okunan 0–1023 değerini servo için 0–180 dereceye ya da analogWrite() için 0–255 PWM değerine dönüştürmektir. Kütüphane gerektirmez, Arduino çekirdeğinde hazır gelir.
map() fonksiyonu ondalıklı sayı döndürür mü?
Hayır. map() long türüyle çalışır ve bölmede ondalık kısmı atar; örneğin map(512, 0, 1023, 0, 5) sonucu 2,5 değil 2 olur. Ondalık gerekiyorsa aynı formülle float parametreli bir mapFloat() fonksiyonu yazmalı ya da sonucu milivolt gibi daha küçük bir birimde hesaplamalısın.
map() ile constrain() arasındaki fark nedir?
map() değeri bir ölçekten diğerine çevirir ama sınırlamaz; giriş aralık dışındaysa çıkış da dışarı taşar. constrain() ise ölçek değiştirmez, yalnızca değeri belirlediğin alt ve üst sınır arasına sıkıştırır. Güvenli kullanım için ikisi birlikte yazılır: map(constrain(x, 200, 900), 200, 900, 0, 255).
Potansiyometre ile servo açısı nasıl ayarlanır?
Potansiyometrenin orta ucunu A0'a, servonun sinyal kablosunu D9'a bağla. loop() içinde int aci = map(analogRead(A0), 0, 1023, 0, 180); satırıyla açıyı hesapla ve servo.write(aci) ile servoya gönder. Servo titrerse birkaç okumanın ortalamasını al ya da küçük değişimleri yok say.
ESP32'de map() fonksiyonu farklı mı çalışır?
Formül aynıdır, ancak ESP32'nin ADC'si 12 bit olduğu için analogRead() 0–4095 döndürür. Bu yüzden giriş aralığını map(x, 0, 4095, 0, 255) şeklinde yazmalısın. ESP32 ADC'si uçlarda doğrusal olmadığından gerçek en küçük ve en büyük okumaları ölçüp kullanmak daha iyi sonuç verir.
MicroPython'da Arduino map() fonksiyonunun karşılığı var mı?
Hazır bir karşılığı yoktur; Python'daki map() listelere fonksiyon uygulayan farklı bir yapıdır. (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min formülüyle kısa bir fonksiyon yazarsın. Pico'da read_u16() 0–65535 döndürdüğü için giriş aralığı genellikle bu değerlerdir.
Bu yazıdan sonra yapabileceğin projeler
Tüm projeleri gör
Hız Ayarlı Yürüyen Led
Altı LED sırayla yanıp söner ve ışık sanki bir uçtan öbür uca koşar. Potansiyometrenin düğmesini çevirdikçe bu koşunun hızı anında değişir: bir yöne çevirince ışık uçar, öbür yöne çevirince her LED…

Hız Ayarlı Karaşimşek Led
Altı LED üzerinde bir ışık bir uçtan öbür uca koşar, döner ve yeniden koşar. Potansiyometrenin düğmesini çevirerek bu koşunun hızını anında ayarlarsın: düğme bir yandayken ışık neredeyse uçar, öbür…

Ldr İle Işık Şiddeti Okuma
Odanın ne kadar aydınlık olduğunu sayıyla görmek ister misin? Işığa duyarlı küçük bir parça olan LDR ortam ışığını ölçer ve Arduino bu değeri yarım saniyede bir bilgisayar ekranına yazar.

Potansiyometre İle Servo Motor Kullanım
Potansiyometrenin düğmesini çevirdikçe servo motorun kolu da onunla birlikte döner; düğmenin bir ucu sıfır dereceye, öbür ucu yarım tura karşılık gelir.

ESP32 Potansiyometre ile LED Parlaklık (Analog → PWM)
Bu projede bir potansiyometre ile LED parlaklığını analog olarak kontrol ediyoruz. ESP32'nin ADC pini potansiyometreden gelen 0-3.3V gerilimi okur, ardından bu değer PWM (Pulse Width Modulation) sinyaline çevrilerek LED'e gönderilir. Böylece potansiyometreyi çevirdikçe LED kademeli olarak parlar ve söner. Arduino Core 3.0+ ile analogWrite() doğrudan kullanılabilir; ESP32-S2/S3'te ADC çözünürlüğü 12-bit'e sabitlenir.

ESP32 Servo Motor (Potansiyometre Kontrolü)
Bu projede potansiyometre ile SG90 servo motoru kontrol ediyoruz. Potansiyometreden okunan analog değeri 0-180 derece aralığına map'leyerek servo açısını ayarlıyoruz. ESP32Servo kütüphanesi, ESP32'nin çıkış verebilen uygun GPIO'larında servo sinyali üretir; bu projede GPIO 18 kullanılır. Bu, robotik kollar, kamera gimbal'ları ve otomatik kapı mekanizmaları için temel bir kontrol yöntemidir.

Joystick İle Servo Kontrol
Bir oyun kolu çubuğuyla iki motoru yönet, tıpkı bir güvenlik kamerasını çevirir gibi.
Diğer yazılar
BlueGrays uygulaması
Bu devreyi telefonunda adım adım kur
Devre şeması, kod ve parça listesi tek ekranda. 500'den fazla Arduino, ESP32 ve Pico projesi seni bekliyor.
Telefonunla tara
Kamerayı koda tut; telefonunun uygulama mağazası açılır.
ya da mağazada aç

