Motor DC vs Servo vs Stepper: Perbedaan dan Cara Memilihnya

Perbedaan motor DC, motor servo, dan motor stepper bisa dirangkum dalam satu kalimat: motor DC berputar terus dan cepat selama kamu memberinya daya, servo bergerak ke sudut yang kamu minta dan menahannya di sana, dan motor stepper berputar dalam langkah-langkah kecil yang bisa dihitung. Jadi kalau kamu perlu memutar roda, pilih motor DC; untuk membuka tutup sebesar 90 derajat, servo; untuk menggerakkan suatu bagian dengan presisi sepersepuluh milimeter, stepper. Setiap kali ada yang harus bergerak di proyek Arduino, ESP32, atau Raspberry Pi Pico, kamu akan bertemu salah satu dari ketiga motor ini.

Di panduan ini kita membandingkan apa yang ada di dalam tiap motor, angka nyata kecepatan, torsi, dan akurasi posisi dari model-model populer (motor TT, SG90, MG996R, 28BYJ-48, NEMA 17), driver apa yang dibutuhkan masing-masing (L298N, sinyal PWM, ULN2003, A4988), berapa arus yang ditariknya, dan motor mana yang dipakai di proyek apa. Di bagian akhir ada kode Arduino, ESP32, dan Pico yang menggerakkan ketiganya sekaligus, pengenalan singkat motor brushless (BLDC) dan ESC, serta kesalahan yang paling sering terjadi.

Jawaban singkat: tiga motor dibandingkan dalam satu tabel

Baris terpenting di tabel ini adalah umpan balik. Servo tahu posisinya berkat potensiometer di dalamnya, dan ketika ada yang mendorongnya, ia kembali ke posisinya. Stepper tidak tahu posisinya; kamu hanya menghitung berapa langkah yang sudah diambilnya, dan hitungan itu benar selama motor tidak kelebihan beban dan tidak melewatkan langkah. Motor DC sama sekali tidak tahu sudah berputar sejauh apa; kalau kamu butuh posisi, kamu harus menambahkan encoder di porosnya. Motor mana yang kamu pilih sangat bergantung pada apakah proyekmu membutuhkan informasi ini.

Bagaimana cara kerja motor DC?

Hampir semua motor DC di proyek hobi adalah motor DC brushed (bersikat). Di dalamnya ada magnet tetap dan kumparan yang berputar (rotor); sikat karbon dan komutator tembaga membalik arah arus ketika rotor berputar, sehingga putarannya terus berlanjut. Motor ini punya dua kabel: beri tegangan dan ia berputar, tukar kabelnya dan ia berputar ke arah sebaliknya. Tegangan menentukan kecepatan, sedangkan arus yang ditariknya menentukan torsi. Selama motor berputar, kumparannya menghasilkan tegangan lawan yang disebut back EMF (GGL balik) yang membatasi arus; ketika porosnya tertahan, back EMF itu hilang dan arus melonjak ke arus stall (arus macet).

Motor DC kecil tanpa gearbox berputar ribuan RPM tetapi torsinya sangat kecil, itulah sebabnya robot selalu memakai motor bergearbox. Gearbox 1:48 di motor TT menurunkan sekitar 12.000 RPM di poros motor menjadi 250 RPM di roda sambil melipatgandakan torsi sekitar 48 kali (dikurangi rugi-rugi roda gigi). Kecepatan kamu ubah dengan PWM dan arah dengan H-bridge; detailnya ada di Mengendalikan Motor DC dengan L298N. Kelemahan motor DC adalah posisi: nilai PWM yang sama memberi kecepatan berbeda tergantung tegangan baterai dan beban, jadi perintah “maju selama 2 detik” menempuh jarak yang berbeda setiap kali. Kalau kamu butuh jarak yang pasti, tambahkan encoder di roda.

Bagaimana cara kerja motor servo?

Motor servo sebenarnya adalah sistem lengkap yang dikemas dalam kotak kecil: motor DC, rangkaian roda gigi yang menurunkan kecepatan dan menaikkan torsi, potensiometer yang terpasang di poros output, dan rangkaian kontrol. Arduino tidak mengirim sudut langsung ke servo, melainkan pulsa 50 Hz (sekali setiap 20 ms); lebar pulsa itulah yang menggambarkan posisi yang diinginkan. Rangkaian kontrol membandingkan target itu dengan posisi sebenarnya yang dibaca dari potensiometer dan menggerakkan motor ke arah tersebut sampai selisihnya nol. Ini disebut kendali loop tertutup (closed loop), dan inilah sebabnya servo melawan ketika kamu mencoba memutarnya dengan tangan.

Rentang RC standar adalah 1–2 ms, tetapi kebanyakan servo murah seperti SG90 butuh sekitar 0,5–2,4 ms untuk 180° penuh, dan library Servo Arduino secara default memakai 544–2400 µs. Dead band SG90, yaitu batas perubahan kecil yang belum direspons servo, sekitar 10 µs, yang setara dengan kira-kira 1°; itulah sebabnya presisi praktis servo sekitar satu derajat. Servo putaran kontinu (FS90R) adalah servo yang umpan baliknya dinonaktifkan: kamu mengendalikan kecepatan dan arah, bukan sudut, dan informasi posisi hilang. Kalau butuh tenaga lebih, MG996R dengan roda gigi logam adalah pilihan standar; untuk dasarnya, lihat Apa Itu Motor Servo?

Bagaimana cara kerja motor stepper?

Motor stepper tidak punya sikat. Kumparan di rumah motor diberi arus dengan urutan tertentu, dan rotor magnetnya mengambil satu langkah ke arah kumparan berikutnya setiap kali. Stepper hybrid yang paling umum punya 200 langkah per putaran, atau 1,8° per langkah. Kirim sejumlah pulsa dan ia mengambil langkah sebanyak itu; kirim lebih cepat dan ia berputar lebih cepat. Selama kumparan diberi arus, motor tetap terkunci di tempatnya; ini disebut holding torque (torsi penahan). Perbedaan kuncinya: stepper bersifat loop terbuka (open loop). Kalau beban melebihi torsinya, ia melewatkan langkah, dan Arduino tidak pernah menyadarinya. Itulah sebabnya printer 3D menggerakkan setiap sumbu ke limit switch ketika dinyalakan (homing).

Ada dua jenis stepper yang akan kamu temui. Motor unipolar (28BYJ-48, 5 kabel) punya kabel bersama untuk kumparannya dan digerakkan oleh susunan transistor sederhana seperti ULN2003. Motor bipolar (NEMA 17, 4 kabel) membutuhkan arus kumparan yang dibalik arahnya, dan itu dilakukan oleh driver pembatas arus seperti A4988, DRV8825, atau TMC2209. Driver ini juga melakukan microstepping: A4988 membagi setiap langkah penuh menjadi 16, menaikkan jumlah langkah per putaran menjadi 3200 dan membuat gerakan jauh lebih senyap dan halus. Untuk detailnya, lihat 28BYJ-48 dan ULN2003 serta driver motor stepper A4988.

Kecepatan, torsi, dan akurasi posisi: angkanya

Torsi biasanya dinyatakan dalam kg·cm: motor 1 kg·cm bisa menahan beban 1 kg pada jarak 1 cm dari porosnya, tetapi hanya 0,5 kg pada jarak 2 cm (1 kg·cm ≈ 0,098 N·m). Contohnya, MG996R pada 6 V memberi 11 kg·cm; di ujung lengan 15 cm, secara teori ia bisa menahan 11 / 15 ≈ 0,73 kg. Tetapi itu adalah torsi puncak pada momen motor stall, dan berat lengan itu sendiri ikut menambah beban. Aturan yang baik agar motor awet adalah tetap di bawah setengah nilai itu, jadi dalam praktiknya kamu bisa membawa beberapa ratus gram di ujung lengan tersebut.

Untuk kecepatan, urutannya terbalik. Motor DC jelas yang paling cepat. Servo SG90 menyelesaikan gerakan 180° dalam sekitar 0,3 detik dan tidak bisa lebih cepat. Torsi stepper turun ketika kecepatan naik, karena arus kumparan tidak sempat naik penuh di setiap langkah; 28BYJ-48 mulai melewatkan langkah di atas sekitar 15 RPM. Memberi daya NEMA 17 pada A4988 dari 24 V alih-alih 12 V menghasilkan torsi lebih besar di kecepatan tinggi, karena driver toh membatasi arusnya. Namun untuk presisi, stepper unggul: NEMA 17 memberi 1,8° dalam mode full-step dan, di atas kertas, 0,1125° pada microstepping 1/16. Satu catatan kecil: rasio gigi internal 28BYJ-48 bukan tepat 1:64 melainkan sekitar 1:63,68, jadi satu putaran sebenarnya sekitar 2038 langkah, bukan 2048; di proyek yang berputar terus, seperti jam, selisih itu menumpuk.

Driver apa yang dibutuhkan tiap motor?

Pin Arduino bisa memberi paling banyak 40 mA, dan batas amannya sekitar 20 mA; bahkan motor TT kecil menarik sekitar 7 kali lipat itu ketika idle dan lebih dari 70 kali lipat ketika stall. Selain itu, kumparan motor menghasilkan lonjakan tegangan balik yang tinggi tepat ketika arusnya diputus, yang bisa merusak pin tanpa proteksi. Itulah sebabnya selalu ada driver di antara motor dan board: board hanya mengirim sinyal kontrol kecil, sementara arus motor mengalir langsung dari catu daya melalui driver. Di dalam driver ada transistor dan dioda yang meredam tegangan balik itu. Untuk kipas atau pompa yang hanya berputar satu arah, satu MOSFET sudah cukup.

Konsumsi daya: berapa arus yang ditarik tiap motor?

Ketiga motor berperilaku sangat berbeda dalam hal arus, dan kamu perlu memilih catu daya sesuai dengan itu. Motor DC menarik arus lebih besar ketika beban bertambah; ketika mulai berputar dan ketika roda macet, arusnya mendekati arus stall. Pilih catu dayamu untuk puncak itu, bukan untuk arus idle. Servo menarik arus sangat kecil ketika menunggu, tetapi menghasilkan lonjakan arus pendek dan tajam setiap kali bergerak: bahkan satu SG90 bisa sejenak melebihi 0,5 A, dan MG996R mencapai 2,5 A ketika dibebani berat. Lonjakan ini menurunkan tegangan dan membuat Arduino reset, atau memicu error brownout di ESP32. Sebaliknya, kumparan stepper tetap dialiri arus bahkan ketika motor sama sekali tidak bergerak: 28BYJ-48 menarik 150–200 mA ketika diam dan menjadi hangat. Di proyek bertenaga baterai, kalau kamu tidak butuh torsi penahan, mematikan kumparan (mengatur pin EN ke HIGH di A4988) memperpanjang umur baterai secara signifikan.

• Pakai catu daya terpisah: Jangan memberi daya motor dari pin 5V Arduino. Port USB memberi sekitar 500 mA dan sebagian sudah dipakai board; selain satu servo kecil, setiap motor butuh catu dayanya sendiri.
• Hubungkan ground-nya: Terminal negatif catu daya motor harus terhubung ke GND board; kalau tidak, sinyal kontrol tidak punya referensi (lihat ground bersama).
• Tambahkan kapasitor: Pasang elektrolit 470–1000 µF di jalur catu daya servo, minimal 47 µF di input VMOT A4988, dan kapasitor keramik 100 nF di antara terminal motor DC brushed. Yang pertama mengurangi penurunan tegangan, yang terakhir mengurangi derau sikat.
• Pilih catu daya untuk arus puncak: Misalnya, lengan robot dengan 4 servo butuh catu daya 5–6 V yang bisa memberi minimal 3 A, dan mobil dengan dua motor TT butuh paket baterai yang sanggup menangani 2 × 1,5 A. Berapa lama baterai bertahan bisa kamu hitung dengan kalkulator umur baterai.
• Turunkan tegangan dengan benar: Kalau kamu butuh 5–6 V untuk servo dari paket baterai 7,4 V, pakai regulator switching seperti LM2596; regulator linear seperti 7805 menjadi sangat panas pada arus dalam orde ampere.

Menggerakkan ketiga motor dari satu Arduino: langkah demi langkah

Cara terbaik untuk melihat perbedaannya adalah menjalankan ketiganya berdampingan. Di rangkaian berikut, motor TT digerakkan oleh L298N, SG90 langsung dari pin, dan 28BYJ-48 oleh board ULN2003. Tabel pin ini berlaku untuk ketiga contoh kode: Arduino Uno, ESP32, dan Raspberry Pi Pico.

1. Lepas jumper ENA di L298N; hubungkan ENA, IN1, dan IN2 ke pin di tabel, lalu motor DC ke terminal OUT1 dan OUT2. Masukkan catu daya motor (misalnya dua sel 18650 seri, 7,4 V) ke terminal 12V.
2. Hubungkan kabel cokelat servo ke GND, kabel merah ke catu daya 5–6 V terpisah, dan kabel sinyal oranye ke D9.
3. Colokkan konektor putih 28BYJ-48 ke board ULN2003, hubungkan IN1–IN4 ke D10–D13, dan beri daya terminal + board dari catu daya 5 V.
4. Hubungkan terminal negatif semua catu daya dan GND Arduino menjadi satu.
5. Upload kode dengan Arduino IDE; library Servo dan Stepper sudah ikut terpasang bersama IDE, jadi kamu tidak perlu menginstalnya.
6. Nyalakan catu daya motor dan perhatikan bagaimana ketiga motor berperilaku satu per satu.

1#include <Servo.h>
2#include <Stepper.h>
3
4// DC motor (L298N): ENA=5, IN1=7, IN2=8
5const int ENA = 5;                 // PWM; Servo kütüphanesi 9 ve 10'un PWM'ini kapatır / Servo library disables PWM on 9 and 10
6const int IN1 = 7;
7const int IN2 = 8;
8
9const int SERVO_PIN = 9;           // servo sinyali / servo signal
10Servo servo;
11
12const int STEPS_PER_REV = 2048;    // 28BYJ-48 tam tur / full revolution
13Stepper stepper(STEPS_PER_REV, 10, 12, 11, 13);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
14
15void releaseStepper() {            // bobinleri bırak, boşta akım çekmesin / release coils, no idle current
16  for (int pin = 10; pin <= 13; pin++) {
17    digitalWrite(pin, LOW);
18  }
19}
20
21void setup() {
22  pinMode(ENA, OUTPUT);
23  pinMode(IN1, OUTPUT);
24  pinMode(IN2, OUTPUT);
25  servo.attach(SERVO_PIN);
26  stepper.setSpeed(10);            // devir/dakika, 28BYJ-48 için en fazla ~15 / RPM, max ~15 for 28BYJ-48
27}
28
29void loop() {
30  // 1) DC motor: hız ve yön, konum yok / speed and direction, no position
31  digitalWrite(IN1, HIGH);
32  digitalWrite(IN2, LOW);
33  analogWrite(ENA, 180);           // yaklaşık %70 güç / about 70% power
34  delay(2000);
35  analogWrite(ENA, 0);             // motoru serbest bırak / let the motor coast
36  delay(500);
37
38  // 2) Servo: açı ver, gidip orada kalsın / give an angle, it goes there and holds
39  servo.write(0);
40  delay(600);
41  servo.write(180);
42  delay(600);
43  servo.write(90);
44  delay(600);
45
46  // 3) Step motor: tam çeyrek tur ileri ve geri / exactly a quarter turn forward and back
47  stepper.step(STEPS_PER_REV / 4);   // 512 adım = 90° / 512 steps = 90°
48  delay(500);
49  stepper.step(-STEPS_PER_REV / 4);
50  releaseStepper();
51  delay(1000);
52}

Ketika kamu menjalankan kodenya, perbedaannya langsung terlihat: motor DC berputar selama dua detik, tetapi porosnya berhenti di titik yang berbeda setiap kali. Servo melompat ke 0°, 180°, dan 90°, dan melawan kalau kamu mencoba memutarnya dengan tangan. Stepper perlahan bergerak tepat seperempat putaran dan kembali ke titik yang sama; setelah releaseStepper() dipanggil, porosnya bisa kamu putar bebas dengan tangan. Fungsi step() di library Stepper menahan kode sampai gerakan selesai; kalau kamu ingin menggerakkan beberapa motor sekaligus dengan akselerasi yang halus, beralihlah ke library AccelStepper.

Motor DC, servo, dan stepper dengan ESP32

Pin ESP32 mengeluarkan 3,3 V; input L298N dan ULN2003 membaca level ini sebagai HIGH, dan servo juga bekerja dengan sinyal 3,3 V. Motor tetap butuh catu dayanya sendiri. Perbedaannya ada di servo: library Servo standar Arduino tidak mendukung ESP32. Kamu bisa menginstal library ESP32Servo atau, seperti di bawah, membuat sinyal 50 Hz sendiri dengan unit PWM hardware ESP32, LEDC. Karena kita memakai dua frekuensi berbeda, 1 kHz untuk motor DC dan 50 Hz untuk servo, kita memasang channel ke timer yang terpisah (channel 0 dan 2) dengan ledcAttachChannel; di beberapa versi core, channel yang bersebelahan memakai timer yang sama. Kode ini untuk ESP32 Arduino core 3.x; di versi 2.x kamu memakai ledcSetup dan ledcAttachPin sebagai gantinya. Library Stepper berjalan tanpa perubahan di ESP32; kalau kamu baru mengenal board ini, lihat Apa Itu ESP32?

1#include <Stepper.h>
2
3// ESP32 Arduino çekirdeği 3.x / ESP32 Arduino core 3.x
4const int ENA = 25;                // L298N hız (PWM) / L298N speed (PWM)
5const int IN1 = 26;
6const int IN2 = 27;
7const int SERVO_PIN = 18;          // servo sinyali / servo signal
8
9const int STEPS_PER_REV = 2048;
10Stepper stepper(STEPS_PER_REV, 19, 22, 21, 23);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
11
12void motor(int speed) {            // -255 … 255
13  digitalWrite(IN1, speed > 0);
14  digitalWrite(IN2, speed < 0);
15  ledcWrite(ENA, abs(speed));
16}
17
18void servoWrite(int angle) {       // 0 … 180
19  int us = map(angle, 0, 180, 500, 2400);              // açı → darbe (µs) / angle → pulse (µs)
20  ledcWrite(SERVO_PIN, (uint32_t)us * 65535 / 20000);  // 20 ms içindeki pay / share of the 20 ms period
21}
22
23void setup() {
24  pinMode(IN1, OUTPUT);
25  pinMode(IN2, OUTPUT);
26  ledcAttachChannel(ENA, 1000, 8, 0);        // kanal 0: 1 kHz, 8 bit (0–255) / channel 0: 1 kHz, 8-bit
27  ledcAttachChannel(SERVO_PIN, 50, 16, 2);   // kanal 2, ayrı zamanlayıcı: 50 Hz, 16 bit / channel 2, separate timer: 50 Hz, 16-bit
28  stepper.setSpeed(10);                      // devir/dakika / RPM
29}
30
31void loop() {
32  motor(200);         delay(2000);   // DC: ileri / forward
33  motor(0);           delay(500);    // DC: dur / stop
34  servoWrite(0);      delay(600);    // servo: 0°
35  servoWrite(180);    delay(600);    // servo: 180°
36  servoWrite(90);     delay(600);    // servo: 90°
37  stepper.step(512);  delay(500);    // step: çeyrek tur / quarter turn
38  stepper.step(-512); delay(1000);
39}

Kode MicroPython untuk Raspberry Pi Pico

Di Pico, setiap pin GP bisa mengeluarkan PWM. Di MicroPython kamu mengatur kecepatan motor DC dari 0 sampai 65535 dengan duty_u16() dan lebar pulsa servo dalam nanodetik dengan duty_ns(). Stepper diputar dengan menulis urutan half-step ke empat pin satu per satu; dalam mode half-step, satu putaran 28BYJ-48 adalah 4096 langkah. Kalau kamu baru mengenal Pico, mulailah dari Apa Itu Raspberry Pi Pico?

1from machine import Pin, PWM
2import time
3
4# DC motor (L298N): ENA=GP15, IN1=GP14, IN2=GP13
5ena = PWM(Pin(15))
6ena.freq(1000)
7in1 = Pin(14, Pin.OUT)
8in2 = Pin(13, Pin.OUT)
9
10# Servo: GP16, 50 Hz
11servo = PWM(Pin(16))
12servo.freq(50)
13
14# Step motor (ULN2003): IN1–IN4 = GP2–GP5
15coils = [Pin(n, Pin.OUT) for n in (2, 3, 4, 5)]
16SEQ = [(1,0,0,0), (1,1,0,0), (0,1,0,0), (0,1,1,0),
17       (0,0,1,0), (0,0,1,1), (0,0,0,1), (1,0,0,1)]   # yarım adım dizisi / half-step sequence
18
19def motor(speed):                    # -100 … 100
20    in1.value(speed > 0)
21    in2.value(speed < 0)
22    ena.duty_u16(int(abs(speed) * 655.35))
23
24def servo_angle(angle):              # 0 … 180
25    us = 500 + angle * 1900 // 180   # 500–2400 µs
26    servo.duty_ns(us * 1000)
27
28phase = 0                            # dizideki konum, çağrılar arasında korunur / position in the sequence, kept between calls
29
30def step(steps, delay_ms=2):         # yarım adımda 4096 adım = 1 tur / 4096 half-steps = 1 turn
31    global phase
32    d = 1 if steps > 0 else -1
33    for _ in range(abs(steps)):
34        phase = (phase + d) % 8
35        for pin, v in zip(coils, SEQ[phase]):
36            pin.value(v)
37        time.sleep_ms(delay_ms)
38    for pin in coils:
39        pin.value(0)                 # bobinleri bırak / release coils
40
41while True:
42    motor(70)                        # DC: %70 ileri / 70% forward
43    time.sleep(2)
44    motor(0)                         # DC: dur / stop
45    time.sleep(0.5)
46    for a in (0, 180, 90):           # servo: üç açı / three angles
47        servo_angle(a)
48        time.sleep(0.6)
49    step(1024)                       # step: çeyrek tur / quarter turn
50    time.sleep(0.5)
51    step(-1024)
52    time.sleep(1)

Motor mana untuk proyek apa?

Di beberapa proyek, kedua jenis motor sama-sama bisa dipakai, dan pilihannya bergantung pada detail. Di mobil robot, motor DC sudah cukup untuk roda, tetapi kalau kamu ingin mobil menempuh tepat 50 cm, kamu menambahkan encoder atau menggerakkan roda dengan stepper. Di lengan robot, servo adalah jalan termudah; lengan yang berat dan presisi memakai stepper dengan roda gigi di sendinya. Di printer 3D, mudah menghitung berapa langkah yang dibutuhkan sebuah sumbu per milimeter: dengan motor 200 langkah, microstepping 1/16, dan puli GT2 20 gigi (jarak antargigi 2 mm), hasilnya 200 × 16 / (20 × 2) = 80 langkah/mm; dengan lead screw T8 yang lead-nya 8 mm, menjadi 200 × 16 / 8 = 400 langkah/mm. Untuk proyek yang menyapu 0–180°, seperti radar atau pelacak matahari, servo adalah solusi yang paling murah sekaligus paling sederhana.

Pengenalan singkat motor brushless (BLDC) dan ESC

Motor DC brushless (BLDC) dibuat dengan susunan terbalik: magnetnya ada di bagian yang berputar dan kumparannya di rumah motor yang diam. Tanpa sikat dan komutator, tidak ada gesekan, percikan api, atau keausan; motornya lebih efisien, lebih senyap, dan jauh lebih awet. Harganya, arah arus sekarang harus dibalik oleh rangkaian elektronik, bukan oleh sikat. Itulah sebabnya motor BLDC punya 3 kabel dan tidak akan berputar kalau dihubungkan langsung ke baterai. Untuk motor model, kecepatan dinyatakan dengan rating KV, yaitu RPM tanpa beban per volt. Motor 1000 KV (mis. A2212) dengan LiPo 3 sel (11,1 V) berputar sekitar 11.100 RPM tanpa beban. Drone, pesawat RC, skateboard dan skuter listrik, kipas komputer, dan hard disk semuanya memakai motor brushless.

Untuk menghubungkan motor BLDC ke Arduino, kamu butuh ESC (electronic speed controller, pengendali kecepatan elektronik). ESC mengubah tegangan DC baterai menjadi pulsa tiga fase untuk motor; ESC sensorless memperkirakan posisi rotor dari back EMF di kumparan yang sedang tidak dialiri arus. Bagian yang menyenangkan, input kontrol ESC sama dengan servo: dalam pulsa 50 Hz, 1000 µs berarti berhenti dan 2000 µs berarti throttle penuh. Rating arus ESC (mis. 30 A) harus lebih tinggi dari arus maksimum yang bisa ditarik motor, dan kebanyakan ESC punya output BEC yang memberi 5 V. Demi keamanan, ESC ingin melihat throttle minimum dulu ketika dinyalakan; ini disebut arming, dan ESC tidak akan memutar motor sebelum mendapat sinyal itu. Di kode berikut, kabel sinyal ESC masuk ke D9 dan kaki tengah (wiper) potensiometer pengatur throttle masuk ke A0.

1#include <Servo.h>
2
3Servo esc;                         // ESC bir servo gibi sürülür / an ESC is driven like a servo
4const int POT_PIN = A0;            // gaz potansiyometresi / throttle potentiometer
5
6void setup() {
7  esc.attach(9, 1000, 2000);       // 1000–2000 µs aralığı / 1000–2000 µs range
8  esc.writeMicroseconds(1000);     // en düşük gaz: ESC'yi kur (arming) / minimum throttle: arm the ESC
9  delay(3000);                     // bip seslerini bekle / wait for the beeps
10}
11
12void loop() {
13  int throttle = map(analogRead(POT_PIN), 0, 1023, 1000, 2000);   // pot → gaz / pot → throttle
14  esc.writeMicroseconds(throttle);
15  delay(20);                       // bir servo periyodu / one servo period
16}

Kesalahan umum dan cara mengatasinya

• Arduino reset ketika motor berjalan: Motor atau servo diberi daya dari pin 5V board. Pakai catu daya terpisah, hubungkan ground-nya, dan tambahkan kapasitor besar di catu daya.
• Servo bergetar atau melompat-lompat: Catu dayanya lemah, kabelnya tipis dan panjang, atau ground-nya tidak tersambung bersama. Hubungkan servo ke catu daya 5–6 V yang bisa memberi minimal 1 A.
• Kecepatan motor DC tidak berubah ketika servo dipakai: Di Uno, ENA terhubung ke pin 9 atau 10, dan library Servo menonaktifkan PWM di pin tersebut. Pindahkan ENA ke 3, 5, 6, atau 11.
• Motor DC tidak berputar pada nilai PWM rendah, hanya berdengung: Dayanya tidak cukup untuk mengatasi gesekan statis. Jalankan motor dengan nilai tinggi sejenak lalu turunkan kecepatannya, atau jaga nilai minimum di sekitar 80–100. Perhitungkan juga drop tegangan L298N yang sekitar 2 V.
• Stepper bergetar tetapi tidak berputar: Urutan kumparan salah atau kecepatannya terlalu tinggi. Untuk 28BYJ-48, pakai urutan Stepper(2048, IN1, IN3, IN2, IN4) dan jaga kecepatan di bawah 15 RPM.
• Stepper melewatkan langkah: Bebannya terlalu berat, akselerasinya terlalu kasar, atau batas arus A4988 terlalu rendah. Atur Vref dengan rumus I = Vref / (8 × Rcs), dengan Rcs adalah resistor sensor arus di board, dan pakai akselerasi yang lembut dengan AccelStepper.
• A4988 terbakar: Kabel motor dicolok atau dicabut ketika driver masih menyala, Vref terlalu tinggi, atau tidak ada kapasitor di VMOT. Selalu hubungkan motor ketika daya mati.
• ESC tidak memutar motor dan terus berbunyi bip: ESC tidak mendapat sinyal throttle minimum ketika dinyalakan. Pastikan setup() mengirim writeMicroseconds(1000) dan menunggu beberapa detik; kalau perlu, kalibrasi ESC seperti yang dijelaskan di manualnya.

Singkatnya, motor DC berarti kecepatan, servo berarti sudut, dan stepper berarti posisi; pasangkan motor yang tepat dengan driver yang tepat, dan separuh proyekmu sudah beres. Mulai dengan SG90 dan motor TT, lalu lanjut ke stepper, adalah cara termudah untuk mempelajari ketiganya. Di aplikasi BlueGrays kamu akan menemukan proyek Menggunakan Motor Servo, Menggerakkan Motor Servo dengan Potensiometer, Menggunakan Motor Stepper, Servo 360 Derajat dari Motor Stepper, Mobil Kendali Bluetooth dengan L298N, dan Robot Penghindar Rintangan, masing-masing langkah demi langkah dengan skema rangkaian dan kode.