Fungsi map() Arduino: Cara Pakai, Contoh, dan constrain()
Bagaimana cara memakai fungsi map() di Arduino? Sintaks, jebakan pembagian bulat, membatasi nilai dengan constrain(), contoh potensiometer ke servo dan PWM, plus ESP32 dan Pico.
Fungsi Arduino map() adalah perintah bawaan yang mengubah nilai dari satu rentang angka ke rentang lain secara proporsional. Ketika kamu ingin mengubah pembacaan 0–1023 dari potensiometer menjadi 0–180 derajat untuk servo, nilai PWM 0–255 untuk kecerahan LED, atau 0–100 persen untuk ditampilkan di layar, fungsi ini menyelesaikannya dalam satu baris. Singkatnya, map() adalah pengubah skala yang mencocokkan skala yang kamu punya dengan skala yang kamu inginkan.
Tapi map() tidak sepolos kelihatannya: fungsi ini hanya bekerja dengan bilangan bulat, membuang bagian desimal, dan tidak membatasi hasilnya ke rentang tujuan. Di artikel ini kamu akan melihat rumus fungsinya, kejutan yang muncul akibat pembagian bulat, pemakaian aman dengan constrain(), contoh nyata dari potensiometer ke servo dan dari sensor ke PWM, serta cara melakukan hal yang sama di ADC 12-bit milik ESP32 dan di Raspberry Pi Pico dengan MicroPython, langkah demi langkah.

Apa itu map() di Arduino dan bagaimana cara kerjanya?
map() membuat perbandingan linear antara dua rentang. Fungsi ini mencari di posisi berapa persen nilai input berada di rentangnya sendiri, lalu menghitung angka di posisi yang sama pada rentang tujuan. Definisinya di core Arduino hanya satu baris: (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min. Semua parameter dan nilai kembaliannya bertipe long, yang di Uno berarti bilangan bulat bertanda 32-bit. Sintaksnya map(value, fromLow, fromHigh, toLow, toHigh), dan kamu tidak perlu menambahkan library apa pun untuk memakainya.
| Parameter | Arti | Contoh pot → servo |
|---|---|---|
| value (x) | Nilai yang akan diubah | Hasil analogRead(A0) |
| fromLow (in_min) | Batas bawah rentang input | 0 |
| fromHigh (in_max) | Batas atas rentang input | 1023 |
| toLow (out_min) | Batas bawah rentang output | 0 |
| toHigh (out_max) | Batas atas rentang output | 180 |
| Nilai kembalian | Padanannya di rentang tujuan (long) | Sudut antara 0 dan 180 |
Yuk hitung dengan contoh: ketika potensiometer tepat di tengah, analogRead() mengembalikan sekitar 512. Untuk map(512, 0, 1023, 0, 180), pertama didapat 512 - 0 = 512, lalu dikalikan dengan 180 - 0 = 180 sehingga hasilnya 92160. Kemudian dibagi 1023: 92160 / 1023 = 90,09. Karena pembagian bulat membuang desimal, hasilnya 90 derajat; terakhir, batas bawah output, yaitu 0, ditambahkan. Kalau kamu menukar batas output, arahnya juga terbalik: map(x, 0, 1023, 255, 0) menghasilkan nilai yang turun ketika potensiometer naik. Rentang negatif juga bekerja dengan baik; kamu bisa mengubah sumbu joystick menjadi kecepatan motor maju-mundur dengan map(x, 0, 1023, -255, 255). Tabel di bawah merangkum konversi yang paling sering dipakai.
| Tujuan | Kode | Catatan |
|---|---|---|
| Potensiometer → sudut servo | map(x, 0, 1023, 0, 180) | Untuk Servo.write() |
| Potensiometer → PWM | map(x, 0, 1023, 0, 255) | Untuk analogWrite(); x / 4 memberi sebaran yang lebih merata |
| Pembacaan analog → persen | map(x, 0, 1023, 0, 100) | Untuk menampilkan persentase di layar |
| Joystick → kecepatan dan arah motor | map(x, 0, 1023, -255, 255) | Tanda menentukan arah, besarnya menentukan kecepatan |
| Arah terbalik (gelap → terang) | map(x, 0, 1023, 255, 0) | Tukar batas output |
| ADC 12-bit ESP32 → PWM | map(x, 0, 4095, 0, 255) | Di ESP32, analogRead() mengembalikan 0–4095 |
Batasan pembagian bulat: kenapa map() tidak memberi desimal?
Karena pembagian di dalam map() dilakukan dengan bilangan bulat, hasilnya selalu dipotong ke arah nol; bagian desimal tidak dibulatkan, tapi langsung dibuang. Di rentang tujuan yang sempit, hal ini jadi sangat terlihat. Misalnya, kalau kamu menulis map(x, 0, 1023, 0, 10) untuk mengubah potensiometer menjadi indikator level 0–10, kamu akan mendapat tabel ini:
| Input (x) | Rasio sebenarnya | Hasil map() |
|---|---|---|
| 0 | 0,000 | 0 |
| 102 | 0,997 | 0 |
| 103 | 1,007 | 1 |
| 512 | 5,005 | 5 |
| 1022 | 9,990 | 9 |
| 1023 | 10,000 | 10 |
Masalah sebenarnya di tabel ini: 103 nilai input berbeda (0–102) menghasilkan 0, sedangkan nilai teratas, 10, hanya dihasilkan oleh satu input, yaitu 1023. Kalau kamu tidak memutar potensiometer sampai mentok, indikatormu tidak akan pernah mencapai 10. Kalau ingin sebaran yang merata, kamu bisa menaikkan kedua batas atas sebesar satu dan menulis map(x, 0, 1024, 0, 11); dengan begitu setiap nilai output berpadanan dengan sekitar 93 nilai input, dan hasilnya tetap berada di antara 0 dan 10. Batasan kedua adalah overflow: kalau hasil kali sementara (x - in_min) * (out_max - out_min) melewati batas long 32-bit, yaitu sekitar 2,1 miliar, hasilnya rusak. Rentang besar seperti map(50000, 0, 100000, 0, 100000) menghasilkan hasil kali sementara 5 miliar di Uno dan memberi hasil yang salah. Batasan ketiga adalah kebutuhan desimal: kalau kamu menulis map(x, 0, 1023, 0, 5) untuk mengubah pembacaan analog menjadi tegangan 0–5 V, kamu hanya mendapat hasil 0, 1, 2, 3, 4, dan 5. Dalam kasus ini, sebaiknya kamu menulis fungsi map floating-point sendiri dengan rumus yang sama:
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}Memakainya bersama constrain
map() tidak menganggap rentang tujuan sebagai batas; fungsi ini hanya menghitung perbandingan. Kalau input keluar dari rentang yang kamu harapkan, output juga ikut keluar. Misalnya kamu sudah mengukur bahwa sebuah LDR sebenarnya memberi nilai antara 200 dan 900, lalu menulis map(x, 200, 900, 0, 255). Ketika senter yang kuat mendorong nilainya sampai 980, hasilnya (980 - 200) * 255 / 700 = 284; kalau nilainya turun ke 150 ketika ruangan sangat gelap, kamu mendapat -18. Di Uno, analogWrite() menafsirkan nilai di atas 255 secara berbeda tergantung pinnya; di pin 6, misalnya, 284 dipotong menjadi 8 bit dan berubah jadi 28, yaitu LED yang hampir padam. Solusinya adalah fungsi constrain(value, low, high): fungsi ini menjepit nilai di dalam batas yang diberikan. Ada dua urutan yang benar: batasi input sebelum map(), yaitu map(constrain(x, 200, 900), 200, 900, 0, 255), atau batasi hasilnya setelah map(), yaitu constrain(map(x, 200, 900, 0, 255), 0, 255). Keduanya mencegah nilai keluar dari 0–255; kalau kamu sedang mengkalibrasi sensor, membatasi input lebih mudah dibaca.
Tabel pengkabelan: Arduino Uno, ESP32, dan Pico
| Koneksi | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Kaki luar potensiometer | 5V dan GND | 3V3 dan GND | 3V3 dan GND |
| Kaki tengah potensiometer | A0 | GPIO 34 | GP26 (ADC0) |
| Titik tengah pembagi LDR + 10 kΩ | A1 | GPIO 35 | GP27 (ADC1) |
| LED (dengan resistor 220 Ω) | D6 (PWM) | GPIO 25 | GP15 |
| Sinyal servo (kabel oranye) | D9 | GPIO 13 | GP16 |
| Rentang pembacaan ADC | 10-bit (0–1023) | 12-bit (0–4095) | read_u16(): 0–65535 |
Langkah demi langkah: mengatur sudut servo dengan potensiometer
- Hubungkan dua kaki luar potensiometer 10 kΩ ke pin 5V dan GND di Arduino, dan kaki tengahnya ke A0.
- Hubungkan kabel cokelat servo SG90 ke GND, kabel merahnya ke 5V, dan kabel sinyal oranyenya ke D9.
- Pastikan library Servo sudah terinstal; library ini sudah ikut bersama Arduino IDE, jadi kamu tidak perlu mengunduh apa pun.
- Upload kode di bawah dan buka Serial Monitor di 9600 baud.
- Sambil memutar potensiometer, perhatikan nilai mentah dan sudut berubah bersamaan di layar, dan servo berputar antara 0 dan 180 derajat.
- Kalau servo terlihat memaksa dan berdengung di titik ujung, persempit output map() ke rentang seperti 10–170.
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}Di kode ini, analogRead() mengembalikan nilai 10-bit, map() mengubahnya menjadi derajat, dan constrain() menjamin bahwa meskipun nanti kamu mengubah rentangnya, tidak ada sudut di luar 0–180 yang dikirim ke servo. Karena ADC Uno sedikit berderau, nilainya bisa bergeser antara 511, 512, dan 513 walaupun kamu tidak menyentuh potensiometer, dan itu membuat servo bergetar. Merata-ratakan beberapa pembacaan, atau memanggil servo.write() hanya ketika sudut berubah lebih dari 2 derajat, sebagian besar menyelesaikan masalah ini. Untuk detailnya, lihat artikel tentang servo bergetar dan menyaring data sensor. Kalau kamu penasaran bagaimana servo bekerja, Apa Itu Motor Servo? adalah titik awal yang bagus.
Dari sensor ke PWM: kecerahan LED otomatis dengan LDR
map() bukan hanya untuk potensiometer; fungsi ini bisa dipakai dengan semua sensor analog. Di contoh ini, satu ujung LDR terhubung ke 5V dan ujung lainnya ke A1; resistor 10 kΩ juga dipasang di antara A1 dan GND. Dengan pengkabelan ini, ketika cahaya bertambah, hambatan LDR turun dan tegangan di A1 naik. Pertama, catat nilai yang terbaca di Serial Monitor di ruangan gelap dan di cahaya terang; misalnya 150 dan 850. Dua angka ini adalah batas kalibrasimu. Kodenya membuat LED makin terang ketika ruangan makin gelap, jadi rentang outputnya ditulis terbalik: dari 255 ke 0. Untuk cara kerja LDR, lihat Sensor Cahaya LDR, dan untuk latar belakang PWM, lihat Apa Itu PWM?.
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}map() di ESP32: ADC 12-bit dan PWM LEDC
Di ESP32, map() bekerja dengan cara yang sama; yang berubah adalah rentang inputnya. ADC ESP32 secara default beresolusi 12 bit, jadi analogRead() mengembalikan 0–4095, bukan 0–1023. Kalau kamu membiarkan map(x, 0, 1023, ...) di kode yang dipindahkan dari Uno, seluruh rentang output sudah habis di seperempat pertama putaran potensiometer, dan di sisa putarannya nilainya meluap sampai empat kali rentang tujuan. Jadi di ESP32, tulis inputnya sebagai 0–4095, atau turunkan ke 10 bit dengan analogReadResolution(10). Di sisi PWM, ESP32 memakai unit LEDC; core Arduino 3.x memperkenalkan ledcAttach(pin, frequency, resolution), sedangkan 2.x memakai ledcSetup() dan ledcAttachPin() yang berbasis channel. Kode di bawah bisa dikompilasi di kedua versi. Karena pin ADC2 tidak bisa dibaca selama Wi-Fi aktif, kita menghubungkan potensiometer ke GPIO 34, yang ada di ADC1. Kalau kamu ingin menggerakkan servo di ESP32, kamu bisa memakai logika yang sama dengan library ESP32Servo dan baris map(x, 0, 4095, 0, 180).
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}ADC ESP32 punya satu kebiasaan yang perlu kamu ketahui: tidak linear di bagian ujung. Dengan pengaturan atenuasi default, tegangan di bawah sekitar 0,1 V terbaca sebagai 0, dan di atas sekitar 3,1 V nilainya jenuh di 4095; di antaranya, pengukurannya sedikit melengkung. Jadi kamu bisa mencapai 4095 sebelum memutar potensiometer sampai mentok, atau merasakan zona mati di awal. Solusi praktisnya adalah mengukur pembacaan minimum dan maksimum yang sebenarnya, lalu memakai batas itu di map() dan constrain(). Kalau kamu butuh nilai tegangan, fungsi analogReadMilliVolts(), yang memakai kalibrasi pabrik, memberi hasil yang lebih akurat daripada map. Untuk fitur umum board-nya, lihat Apa Itu ESP32?.
Padanan map() di Raspberry Pi Pico dan MicroPython
MicroPython tidak punya map() siap pakai seperti di Arduino; map() di Python melakukan hal yang sama sekali berbeda, yaitu menerapkan fungsi ke sebuah list. Jadi kamu menulis rumus yang sama sendiri. Di Pico, ADC.read_u16() mengembalikan pengukuran fisik 12-bit yang sudah diskalakan ke 16 bit, dalam rentang 0–65535; PWM.duty_u16() juga mengharapkan nilai duty antara 0 dan 65535. Karena bilangan bulat Python ukurannya tidak terbatas, kamu tidak mengalami masalah overflow seperti di Uno. Perbedaan yang perlu diperhatikan: operator // selalu membulatkan ke arah minus tak hingga, sedangkan map() di C++ memotong ke arah nol, jadi di rentang negatif kamu bisa melihat selisih 1 satuan antara kedua bahasa. Kalau ingin hasil desimal, cukup pakai / sebagai ganti //. Di kodenya, potensiometer dibaca dari GP26, LED di GP15 mengikuti kecerahan, dan servo di GP16 mengikuti sudut. Untuk LED, kita membatasi input ke 500–65000, karena ADC Pico jarang mencapai tepat 0 dan 65535 di ujungnya. Di sisi servo, 0–180 derajat pada PWM 50 Hz berpadanan dengan pulsa sekitar 500–2500 mikrodetik untuk kebanyakan SG90. Kalau kamu baru mengenal Pico, kamu bisa mulai dari Apa Itu Raspberry Pi Pico? dan dasar-dasar 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)Ide proyek dengan map()
- Indikator level: Ubah nilai potensiometer atau sensor suara menjadi 0–8 dengan map(x, 0, 1024, 0, 9) dan tampilkan di bar 8 LED.
- Mobil yang dikendalikan joystick: Ubah sumbu joystick menjadi antara -255 dan 255, lalu atur arah dan kecepatan motor dengan L298N.
- Voltmeter digital: Ubah pembacaan analog menjadi milivolt dan tampilkan di LCD; detailnya ada di Membuat Voltmeter Arduino.
- Persentase kelembapan tanaman: Ubah nilai kalibrasi kering dan basah dari sensor kelembapan tanah menjadi persentase 0–100 dengan constrain() dan map().
- Alat musik yang dikendalikan cahaya: Ubah nilai LDR atau jarak ke rentang 200–2000 Hz dengan map() dan berikan ke tone() sebagai frekuensi.
- LED berjalan dengan kecepatan yang bisa diatur: Ubah potensiometer menjadi waktu jeda dalam milidetik dengan map(x, 0, 1023, 50, 500).
Kesalahan umum dan cara mengatasinya
| Gejala | Penyebab | Solusi |
|---|---|---|
| Hasilnya keluar dari rentang tujuan | map() tidak membatasi nilai | Batasi input atau output dengan constrain() |
| Hasil desimal selalu keluar sebagai bilangan bulat | Pembagian bulat membuang desimal | Tulis mapFloat() atau pakai satuan yang lebih kecil (mV, bukan V) |
| Nilai teratas tidak pernah tercapai | Nilai teratas hanya muncul untuk satu input | Ratakan sebarannya dengan map(x, 0, 1024, 0, max + 1) |
| Hasil ngawur dengan angka besar | Hasil kali sementara melewati batas long 32-bit | Perkecil rentangnya atau hitung dengan float atau int64_t |
| Di ESP32 nilainya terlalu cepat mentok di batas atas | Kodenya ditulis untuk 0–1023, tapi ADC memberi 0–4095 | Jadikan rentang input 0–4095 |
| Arahnya bekerja terbalik | Batas output atau pengkabelan sensor terbalik | Tukar batas bawah dan batas atas output |
| Hasilnya konstan dan tidak bermakna | in_min sama dengan in_max, artinya pembagian dengan nol | Pastikan batas kalibrasinya berbeda |
Fungsi map() adalah penerjemah antara dunia sensor dan dunia output: ingat soal pembagian bulat, lindungi batasnya dengan constrain(), dan kalau kamu menulis resolusi ADC board-mu dengan benar, fungsi ini bekerja dengan logika yang sama di Uno, ESP32, dan Pico. Kamu bisa mengulang dasar-dasar potensiometer di Apa Itu Potensiometer?. Di aplikasi BlueGrays, kamu bisa menjelajahi proyek yang memakai map(), seperti LED berjalan dengan kecepatan yang bisa diatur, mengukur intensitas cahaya dengan LDR, mengendalikan servo dengan potensiometer, dan mengatur kecerahan PWM dengan ESP32, langkah demi langkah lengkap dengan skema rangkaian dan kodenya.
Pertanyaan umum
Apa fungsi map() di Arduino?
map() mengubah angka di satu rentang ke rentang lain secara proporsional. Pemakaian paling umumnya adalah mengubah nilai 0–1023 yang dibaca dengan analogRead() menjadi 0–180 derajat untuk servo atau nilai PWM 0–255 untuk analogWrite(). Fungsi ini tidak butuh library dan sudah tersedia di core Arduino.
Apakah map() mengembalikan angka desimal?
Tidak. map() bekerja dengan tipe long dan membuang bagian desimal ketika membagi; misalnya, map(512, 0, 1023, 0, 5) menghasilkan 2, bukan 2,5. Kalau kamu butuh desimal, tulis fungsi mapFloat() dengan parameter float memakai rumus yang sama, atau hitung hasilnya dalam satuan yang lebih kecil seperti milivolt.
Apa bedanya map() dan constrain()?
map() mengubah nilai dari satu skala ke skala lain tapi tidak membatasinya; kalau input berada di luar rentang, output juga ikut keluar. constrain() tidak mengubah skala, hanya menjepit nilai di antara batas bawah dan batas atas yang kamu tentukan. Untuk pemakaian yang aman, keduanya ditulis bersama: map(constrain(x, 200, 900), 200, 900, 0, 255).
Bagaimana cara mengatur sudut servo dengan potensiometer?
Hubungkan kaki tengah potensiometer ke A0 dan kabel sinyal servo ke D9. Di loop(), hitung sudutnya dengan int angle = map(analogRead(A0), 0, 1023, 0, 180); lalu kirim ke servo dengan servo.write(angle). Kalau servo bergetar, rata-ratakan beberapa pembacaan atau abaikan perubahan kecil.
Apakah map() bekerja berbeda di ESP32?
Rumusnya sama, tapi karena ADC ESP32 12-bit, analogRead() mengembalikan 0–4095. Jadi kamu perlu menulis rentang inputnya sebagai map(x, 0, 4095, 0, 255). Karena ADC ESP32 tidak linear di bagian ujung, mengukur dan memakai pembacaan minimum dan maksimum yang sebenarnya memberi hasil yang lebih baik.
Apakah ada padanan fungsi map() Arduino di MicroPython?
Tidak ada padanan siap pakai; map() di Python adalah konstruksi berbeda yang menerapkan fungsi ke list. Kamu menulis fungsi pendek dengan rumus (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min. Karena read_u16() mengembalikan 0–65535 di Pico, rentang inputnya biasanya nilai-nilai itu.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
LED Berjalan dengan Kecepatan yang Bisa Diatur
Enam LED menyala satu demi satu, sehingga cahayanya seolah berlari dari satu ujung ke ujung lainnya.

Efek LED Knight Rider dengan Kecepatan yang Bisa Diatur
Cahaya berlari dari satu ujung enam LED ke ujung lainnya, berbalik, lalu berlari kembali.

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…

Menggerakkan Motor Servo dengan Potensiometer
Ketika kamu memutar kenop potensiometer, lengan motor servo ikut berputar: satu ujung kenop berarti nol derajat, ujung lainnya berarti setengah putaran.

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.

Motor Servo ESP32 (Kendali Potensiometer)
Di proyek ini, kita mengendalikan motor servo SG90 memakai potensiometer. Kita mengatur sudut servo dengan memetakan nilai analog yang dibaca dari potensiometer ke rentang 0–180 derajat. Library ESP32Servo menghasilkan sinyal servo di pin GPIO ESP32 yang sesuai dan bisa menjadi output; proyek ini memakai GPIO 18. Ini metode kendali dasar untuk lengan robot, gimbal kamera, dan mekanisme pintu otomatis.

Kendali Servo dengan Joystick
Arahkan dua motor dengan joystick, persis seperti memutar kamera keamanan. Dorong tuas ke kiri atau kanan dan servo bawah berputar perlahan, dorong ke atas atau bawah dan servo atas mendongak dan…
Artikel lainnya
Aplikasi BlueGrays
Rakit rangkaian ini langkah demi langkah di ponselmu
Skema pengkabelan, kode, dan daftar komponen dalam satu layar. 500+ proyek Arduino, ESP32, dan Pico siap dibuat.
Pindai dengan ponselmu
Arahkan kamera ke kode ini dan toko aplikasi di ponselmu akan terbuka.
atau buka toko aplikasi

