Temeller · 8 dk okuma

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() fonksiyonu ile kullanılan potansiyometre
Potansiyometre, map() fonksiyonunun en sık kullanıldığı giriş elemanıdır: okunan 0–1023 değeri servo açısına ya da PWM değerine çevrilir.

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.

ParametreAnlamıPot → servo örneği
value (x)Dönüştürülecek değeranalogRead(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ğeriHedef 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çKodNot
Potansiyometre → servo açısımap(x, 0, 1023, 0, 180)Servo.write() için
Potansiyometre → PWMmap(x, 0, 1023, 0, 255)analogWrite() için; x / 4 daha eşit dağılım verir
Analog okuma → yüzdemap(x, 0, 1023, 0, 100)Ekranda yüzde göstermek için
Joystick → motor hızı ve yönmap(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 → PWMmap(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 oranmap() sonucu
00,0000
1020,9970
1031,0071
5125,0055
10229,9909
102310,00010

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:

C++ (Arduino IDE)
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}
Uno'da float işlemleri tamsayıya göre birkaç kat yavaştır ve daha fazla program belleği harcar. Ondalık şart değilse tamsayı map() kullan; hassasiyet istiyorsan hedef birimi küçült. Örneğin gerilimi volt yerine milivolt olarak hesapla: map(raw, 0, 1023, 0, 5000) sonucu 0–5000 mV verir ve en büyük ara çarpım (5.115.000) long sınırının çok altında kalır.

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.

Arduino Uno (AVR) çekirdeğinde constrain() bir fonksiyon değil makrodur ve parametrelerini birden fazla kez değerlendirir. constrain(analogRead(A0), 200, 900) yazarsan analogRead() birkaç kez çalışabilir ve karşılaştırılan değerle döndürülen değer farklı olabilir. Okumayı önce bir değişkene al, sonra constrain() içine o değişkeni yaz.

Bağlantı tablosu: Arduino Uno, ESP32 ve Pico

BağlantıArduino UnoESP32Raspberry Pi Pico
Potansiyometre dış uçları5V ve GND3V3 ve GND3V3 ve GND
Potansiyometre orta ucuA0GPIO 34GP26 (ADC0)
LDR + 10 kΩ bölücü orta noktasıA1GPIO 35GP27 (ADC1)
LED (220 Ω dirençle)D6 (PWM)GPIO 25GP15
Servo sinyal (turuncu kablo)D9GPIO 13GP16
ADC okuma aralığı10 bit (0–1023)12 bit (0–4095)read_u16(): 0–65535
ESP32 ve Pico'nun analog girişleri en fazla 3,3 V kabul eder. Potansiyometrenin uçlarını alışkanlıkla 5V pinine bağlarsan orta uç 5 V'a çıkar ve ADC girişi kalıcı olarak zarar görebilir. Bu kartlarda potansiyometreyi her zaman 3V3 pininden besle; 5 V çıkışlı bir sensör kullanıyorsan önce gerilim bölücü ile seviyeyi düşür.

Adım adım: potansiyometre ile servo açısı ayarlamak

  1. 10 kΩ potansiyometrenin iki dış ucunu Arduino'nun 5V ve GND pinlerine, orta ucunu A0'a bağla.
  2. SG90 servonun kahverengi kablosunu GND'ye, kırmızısını 5V'a, turuncu sinyal kablosunu D9'a bağla.
  3. Servo kütüphanesinin kurulu olduğunu kontrol et; Arduino IDE ile birlikte gelir, ayrıca bir şey indirmen gerekmez.
  4. Aşağıdaki kodu yükle ve Seri Monitör'ü 9600 baud hızında aç.
  5. 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.
  6. Servo uç noktalarda zorlanıp vızıldıyorsa map() çıkışını 10–170 gibi daha dar bir aralığa çek.
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

MicroPython
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

BelirtiSebepÇözüm
Sonuç hedef aralığın dışına çıkıyormap() sınırlama yapmazGirişi ya da çıkışı constrain() ile sınırla
Ondalıklı sonuçlar hep tam sayı geliyorTamsayı bölmesi ondalığı atarmapFloat() 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şurmap(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şıyorAralıkları küçült ya da float veya int64_t ile hesapla
ESP32'de değer çok erken tavan yapıyorKod 0–1023 için yazılmış, ADC 0–4095 veriyorGiriş 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ızin_min ile in_max eşit, yani sıfıra bölmeKalibrasyon sınırlarının farklı olduğunu kontrol et
Kalibrasyonu sabit sayılarla yazmak yerine çalışma anında ölç: setup() içinde birkaç saniye boyunca sensörü oku, en küçük ve en büyük değeri kaydet, sonra map() ve constrain() içinde bu değişkenleri kullan. İki değer eşit kalırsa sıfıra bölmemek için varsayılan sınırlara dön. Böylece aynı kod farklı LDR'lerde, potansiyometrelerde ve ortamlarda kendini ayarlar. Analog okumanın arka planını ADC nedir? yazısında bulabilirsin.

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.

Tüm projeleri gör
Hız Ayarlı Yürüyen Led
AR-7Orta

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…

4.6(72)
148
Hız Ayarlı Karaşimşek Led
AR-8Orta

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…

4.5(60)
124
Ldr İle Işık Şiddeti Okuma
AR-11Başlangıç

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.

4.6(83)
143
Potansiyometre İle Servo Motor Kullanım
AR-36Başlangıç
Premium

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.

4.6(37)
53
ESP32 Potansiyometre ile LED Parlaklık (Analog → PWM)
ES-13Orta
Premium

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.

4.5(19)
32
ESP32 Servo Motor (Potansiyometre Kontrolü)
ES-16Orta
Premium

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.

4.3(29)
42
Joystick İle Servo Kontrol
AR-60Orta
Premium

Joystick İle Servo Kontrol

Bir oyun kolu çubuğuyla iki motoru yönet, tıpkı bir güvenlik kamerasını çevirir gibi.

4.7(42)
58